service-bridge 1.8.5-dev.49 → 2.0.0-alpha

package/README.md

@@ -1,1290 +1,623 @@
-<!-- keywords: service-bridge servicebridge npm install service-bridge Node.js TypeScript JavaScript microservices RPC gRPC event-bus event-driven distributed-tracing workflow orchestration background-jobs cron mTLS service-mesh service-discovery distributed-systems zero-sidecar Istio-alternative RabbitMQ-alternative Temporal-alternative Jaeger-alternative PostgreSQL Docker Kubernetes DLQ dead-letter-queue saga distributed-transactions AI-agent-orchestration Express Fastify HTTP-middleware observability Prometheus tracing service-catalog async-messaging durable-events retries idempotency auto-mTLS runtime-dashboard production-ready bun deno -->
+<!--
+Keywords: service-bridge, ServiceBridge, microservices, Node.js SDK, TypeScript SDK, Bun,
+gRPC, mTLS, RPC framework, durable events, pub/sub, message broker alternative, RabbitMQ alternative,
+workflow engine, saga, orchestration, Temporal alternative, job scheduler, cron, distributed tracing,
+observability, OpenTelemetry alternative, Jaeger alternative, service mesh alternative, Istio alternative,
+self-hosted, PostgreSQL, Express, Fastify, Hono, circuit breaker, idempotency, retries, load balancing.
+-->
 
 # service-bridge
 
-[![npm version](https://img.shields.io/npm/v/service-bridge?color=cb3837&logo=npm)](https://www.npmjs.com/package/service-bridge)
-[![License](https://img.shields.io/badge/License-Free%20%2F%20Commercial-blue)](../LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5%2B-3178c6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Node](https://img.shields.io/badge/Node.js-18%2B-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![npm version](https://img.shields.io/npm/v/service-bridge?color=cb3837&label=npm)](https://www.npmjs.com/package/service-bridge)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![TypeScript](https://img.shields.io/badge/types-included-3178c6.svg)](https://www.typescriptlang.org/)
+[![Node](https://img.shields.io/badge/node-%E2%89%A518-339933.svg)](https://nodejs.org/)
 
-**The unified runtime for microservices — RPC, events, workflows, jobs, and observability without a mesh.**
+**The Node.js / Bun SDK for [ServiceBridge](https://servicebridge.dev) — RPC, durable events, workflows, jobs, streaming and full observability over one self-hosted runtime. No broker. No sidecar. No tracing stack. Just one Go binary plus PostgreSQL.**
 
-Node.js SDK for [ServiceBridge](https://servicebridge.dev) — direct gRPC between workers with zero proxy hops; durable events, background jobs, long-running workflows, and distributed tracing in one SDK. Full mesh with circuit breakers, auto mTLS, and hot-reload transport config. Node, Python, and Go — one identical API. One Go runtime and PostgreSQL.
+You declare what your service handles and what it calls. ServiceBridge does the rest: provisions an mTLS identity, opens the connection, registers your handlers, and routes every RPC, event, job and workflow step — with tracing, metrics and access policy built in.
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                    BEFORE: 10 moving parts                      │
-│  Istio · Envoy · RabbitMQ · Temporal · Jaeger · Consul ·       │
-│  cert-manager · Alertmanager · cron · custom glue              │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│               AFTER: ServiceBridge + PostgreSQL                 │
-│  RPC · Events · Workflows · Jobs · Tracing · mTLS · Dashboard  │
-│            One SDK  ·  One runtime  ·  Zero sidecars            │
-└─────────────────────────────────────────────────────────────────┘
+        BEFORE                                       AFTER
+
+  ┌─────────────────────┐
+  │  Istio + Envoy      │  ← mesh / mTLS
+  │  RabbitMQ / Kafka   │  ← events                 ┌──────────────────────┐
+  │  Temporal           │  ← workflows              │                      │
+  │  a cron scheduler   │  ← jobs                   │   ServiceBridge      │
+  │  gRPC plumbing      │  ← RPC          ═══►       │   runtime (1 binary) │
+  │  Jaeger / Tempo     │  ← tracing                │          +           │
+  │  Prometheus wiring  │  ← metrics                │      PostgreSQL      │
+  │  Loki               │  ← logs                   │                      │
+  │  a load balancer    │  ← LB / retries           └──────────────────────┘
+  │  service registry   │  ← discovery
+  └─────────────────────┘
+     10+ moving parts                                  2 things to run
 ```
 
-## Table of Contents
+---
+
+## Table of contents
 
-- [Why ServiceBridge](#why-servicebridge)
-- [Use Cases](#use-cases)
-- [Quick Start](#quick-start)
 - [Install](#install)
-- [Runtime Setup](#runtime-setup)
-- [End-to-End Example](#end-to-end-example)
-- [Platform Features](#platform-features)
-- [How It Compares](#how-it-compares)
-- [API Reference](#api-reference)
-- [HTTP Plugins](#http-plugins)
+- [Why ServiceBridge](#why-servicebridge)
+- [Use cases](#use-cases)
+- [Quick start](#quick-start)
+- [Runtime setup](#runtime-setup)
+- [End-to-end example](#end-to-end-example)
+- [Platform features](#platform-features)
+- [How it compares](#how-it-compares)
+- [API reference](#api-reference)
+  - [RPC](#rpc)
+  - [Events](#events)
+  - [Jobs](#jobs)
+  - [Workflows](#workflows)
+  - [Streaming](#streaming)
+  - [Telemetry](#telemetry)
+  - [HTTP](#http)
+- [HTTP plugins](#http-plugins)
 - [Configuration](#configuration)
-- [Environment Variables](#environment-variables)
-- [Error Handling](#error-handling)
-- [When to Use / When Not to Use](#when-to-use--when-not-to-use)
+- [Error handling](#error-handling)
 - [FAQ](#faq)
-- [Community and Support](#community-and-support)
+- [Community](#community)
 - [License](#license)
 
 ---
 
-## Why ServiceBridge
-
-| Problem | Without ServiceBridge | With ServiceBridge |
-|---|---|---|
-| Service-to-service calls | Istio/Envoy sidecar proxy per pod | **Direct SDK-to-worker gRPC, zero proxy hops** |
-| Async messaging | Kafka/RabbitMQ + retry logic + DLQ setup | **Built-in durable events with retry, DLQ, replay** |
-| Background jobs | Bull/BullMQ + Redis + cron daemon | **Built-in cron and delayed jobs** |
-| Workflow orchestration | Temporal/Conductor cluster + persistence | **Built-in DAG workflows** |
-| Distributed tracing | Jaeger/Tempo + OTEL collector + dashboards | **Built-in traces + realtime UI** |
-| Service discovery | Consul/etcd + DNS glue | **Built-in registry + health-aware balancing** |
-| mTLS | cert-manager + Vault PKI | **Auto-provisioned certs from service key** |
-
-**Result**: `10 tools → 1 runtime`. One Go binary + PostgreSQL replaces the entire stack.
-
----
-
-## Use Cases
-
-**Microservice communication** — Replace sidecar mesh with direct RPC calls. Get sub-millisecond overhead instead of double proxy hop latency.
-
-**Event-driven architecture** — Publish durable events with fan-out, retries, DLQ, idempotency, and server-side filtering. No broker infrastructure to manage.
-
-**Background job scheduling** — Cron jobs, delayed execution, and job-triggered workflows in a single API. No Redis, no separate queue workers.
-
-**Saga / distributed transactions** — DAG workflows with typed steps (`rpc`, `event`, `event_wait`, `sleep`, child workflow). Compensations and rollbacks via workflow step dependencies.
-
-**AI agent orchestration** — Stream LLM tokens via realtime trace streams with replay. Orchestrate multi-step AI pipelines as workflows.
-
-**Full-stack observability** — Every RPC call, event delivery, workflow step, and HTTP request traced automatically. One timeline, one dashboard. Prometheus metrics and Loki-compatible log API included.
-
----
-
-## Quick Start
+## Install
 
-### 1. Install
-
-```bash
+```sh
 npm i service-bridge
 # or
 bun add service-bridge
 ```
 
-### 2. Create a worker (service that handles calls)
+- **Runtime:** Node.js 18+ or any current Bun.
+- **Types:** included, written in TypeScript 5.
+- **Backend:** a running ServiceBridge runtime (gRPC control plane on `:14445`) backed by PostgreSQL 18+. See [Runtime setup](#runtime-setup).
 
 ```ts
-import { servicebridge } from "service-bridge";
+import { ServiceBridge } from "service-bridge";
 
-const sb = servicebridge(
-  process.env.SERVICEBRIDGE_URL ?? "localhost:14445",
-  process.env.SERVICEBRIDGE_SERVICE_KEY!,
+const sb = new ServiceBridge(
+  "localhost:14445", // runtime control-plane address
+  "sb_key_...",      // bootstrap service key from the runtime
 );
-
-sb.handleRpc("payment.charge", async (payload: { orderId: string; amount: number }) => {
-  return { ok: true, txId: `tx_${Date.now()}`, orderId: payload.orderId };
-});
-
-await sb.serve({ host: "localhost" });
 ```
 
-### 3. Call it from another service
-
-```ts
-import { servicebridge } from "service-bridge";
-
-const sb = servicebridge(
-  process.env.SERVICEBRIDGE_URL ?? "localhost:14445",
-  process.env.SERVICEBRIDGE_SERVICE_KEY!,
-);
-
-const result = await sb.rpc<{ ok: boolean; txId: string }>("payments", "payment.charge", {
-  orderId: "ord_42",
-  amount: 4990,
-});
-
-console.log(result.txId); // tx_1711234567890
-```
-
-That's it. No broker, no sidecar, no proxy — direct gRPC call between services.
+The third constructor argument is an [options](#configuration) object. The SDK reads **no environment variables** — every knob is a constructor option, so you stay in control of where config comes from.
 
 ---
 
-## Runtime Setup
+## Why ServiceBridge
 
-The SDK connects to a ServiceBridge runtime. The fastest way to start:
+Microservices rarely fail because of business logic. They fail in the gaps *between* services — the broker that dropped a message, the workflow engine nobody fully understands, the trace that stops at a service boundary, the mesh config that takes a week to debug. Each gap is another system to run, secure and correlate.
 
-```bash
-bash <(curl -fsSL https://servicebridge.dev/install.sh)
-```
+ServiceBridge collapses those gaps into one runtime. Your service talks to a single gRPC endpoint over mTLS; the runtime is the single source of truth for routing, delivery and state.
 
-This installs ServiceBridge + PostgreSQL via Docker Compose and generates an admin password automatically. After install, the dashboard is at `http://localhost:14444` and the gRPC control plane at `localhost:14445`.
+| Problem | Without ServiceBridge | With ServiceBridge |
+|---|---|---|
+| Service-to-service calls | gRPC/HTTP plumbing + a mesh for mTLS + retries | `sb.rpc.call("svc", "Method", req)` — mTLS, LB, retries, breakers built in |
+| Reliable async messaging | Stand up and operate a broker | `sb.event.publish(...)` — durable outbox, at-least-once, fan-out, DLQ |
+| Multi-step business processes | A separate workflow engine to learn and host | `sb.workflow.handle(...)` — durable DAGs with compensation and replay |
+| Scheduled work | A cron box or a job scheduler service | `sb.job.handle(...)` — cron / interval / delay, leased and retried |
+| Knowing what happened | Wire up tracing + metrics + logs across N tools | Every hop is traced, measured and logged automatically |
+| Identity & access | Certificates, a mesh policy layer | mTLS from a service key + granular access policy, on by default |
 
-For manual Docker Compose setup, configuration reference, and all runtime environment variables, see the **[Runtime Setup](../README.md#runtime-setup)** section in the main SDK README.
+One binary, one database, one place to look when something breaks.
 
 ---
 
-## End-to-End Example
-
-A complete order flow: HTTP request → RPC → Event → Event handler with streaming.
-
-```ts
-import { servicebridge } from "service-bridge";
-
-// --- Payments service (worker) ---
+## Use cases
 
-const payments = servicebridge("localhost:14445", process.env.SERVICEBRIDGE_SERVICE_KEY!);
+- **Replace a broker** — durable, at-least-once events with fan-out and a dead-letter queue, without operating Kafka or RabbitMQ.
+- **Run sagas / orchestration** — checkout, onboarding, fulfilment as durable workflows with automatic compensation on failure.
+- **Internal RPC backbone** — typed service-to-service calls with load balancing, retries and circuit breakers, secured by mTLS.
+- **Scheduled & delayed work** — nightly rollups, reminders, periodic syncs as leased, retried jobs.
+- **Streaming responses** — token-by-token LLM output or progress feeds over server-side streaming RPC.
+- **Observability for free** — get a full distributed trace across RPC → event → workflow → job without instrumenting by hand.
 
-payments.handleRpc("payment.charge", async (payload: { orderId: string; amount: number }, ctx) => {
-  await ctx?.stream.write({ status: "charging", orderId: payload.orderId }, "progress");
+---
 
-  // ... charge logic ...
+## Quick start
 
-  await ctx?.stream.write({ status: "charged" }, "progress");
-  return { ok: true, txId: `tx_${Date.now()}` };
-});
+Schemas are **file-based**: point the SDK at a `.proto` file (it resolves request/response types from the `service` block) or a `.schema.json` with explicit field numbers. There is no inline schema.
 
-await payments.serve({ host: "localhost" });
+```proto
+// payment.proto
+syntax = "proto3";
+message ChargeRequest { string user_id = 1; int64 amount = 2; }
+message ChargeReply   { bool ok = 1; }
+service Payment {
+  rpc Charge(ChargeRequest) returns (ChargeReply);
+}
 ```
 
-```ts
-// --- Orders service (caller + event publisher) ---
-
-const orders = servicebridge("localhost:14445", process.env.SERVICEBRIDGE_SERVICE_KEY!);
-
-// Call payments, then publish event
-const charge = await orders.rpc<{ ok: boolean; txId: string }>("payments", "payment.charge", {
-  orderId: "ord_42",
-  amount: 4990,
-});
-
-await orders.event("orders.completed", {
-  orderId: "ord_42",
-  txId: charge.txId,
-}, {
-  idempotencyKey: "order:ord_42:completed",
-  headers: { source: "checkout" },
-});
-```
+**Worker** — register the handler. One argument in, one value out.
 
 ```ts
-// --- Notifications service (event consumer) ---
+import { ServiceBridge } from "service-bridge";
 
-const notifications = servicebridge("localhost:14445", process.env.SERVICEBRIDGE_SERVICE_KEY!);
+const sb = new ServiceBridge("localhost:14445", process.env.PAYMENT_KEY!);
 
-notifications.handleEvent("orders.*", async (payload, ctx) => {
-  const body = payload as { orderId: string; txId: string };
-  await ctx.stream.write({ status: "sending_email", orderId: body.orderId }, "progress");
-  // ... send email ...
-});
-
-await notifications.serve({ host: "localhost" });
-```
+sb.rpc.handle(
+  "Charge",
+  async (req: { userId: string; amount: number }) => {
+    return { ok: req.amount > 0 };
+  },
+  { schema: { protoFile: "./payment.proto" } },
+);
 
-```ts
-// --- Orchestrate as a workflow ---
-
-await orders.workflow("order.fulfillment", [
-  { id: "reserve",  type: "rpc",        service: "inventory", ref: "stock.reserve" },
-  { id: "charge",   type: "rpc",        service: "payments", ref: "payment.charge",      deps: ["reserve"] },
-  { id: "wait_dlv", type: "event_wait", ref: "shipping.delivered",   deps: ["charge"] },
-  { id: "notify",   type: "event",      ref: "orders.fulfilled",     deps: ["wait_dlv"] },
-]);
+await sb.start();
 ```
 
-Every step above — RPC, event publish, event delivery, workflow execution — appears in a single trace timeline in the built-in dashboard.
+**Caller** — in another process, build a typed client and call it. `sb.client()` reads the `.proto` once, declares every method in its `service` block as an outgoing dependency, loads the schemas, and returns a typed proxy.
 
----
-
-## Platform Features
-
-### Communication
-- **Direct RPC** — zero-hop gRPC calls with retries, deadlines, and mTLS identity
-- **Durable Events** — fan-out delivery, guaranteed delivery (RabbitMQ-style), at-least-once guarantees, retries, DLQ, replay, idempotency. If a consumer is offline, the message waits in the server-side queue and is dispatched the moment the consumer reconnects — no retry budget consumed while waiting.
-- **Realtime Streams** — live chunks with replay for AI/progress/log streaming
-- **Service Discovery** — automatic endpoint resolution and round-robin balancing
-- **HTTP Middleware** — Express and Fastify instrumentation with automatic trace propagation
-
-### Orchestration
-- **Workflows** — DAG steps: `rpc`, `event`, `event_wait`, `sleep`, child workflow
-- **Jobs** — cron, delayed, and workflow-triggered scheduling
+```ts
+import { ServiceBridge } from "service-bridge";
 
-### Security
-- **TLS by default** — control plane TLS + worker mTLS with gRPC certificate provisioning
-- **Access Policy** — service-level caller/target restrictions and RBAC
+const sb = new ServiceBridge("localhost:14445", process.env.ORDERS_KEY!);
+const payment = await sb.client("payment-svc", "./payment.proto");
 
-### Observability
-- **Unified Tracing** — single trace timeline across HTTP, RPC, events, workflows, and jobs
-- **Metrics** — Prometheus-compatible `/metrics` endpoint (30+ metric families)
-- **Logs** — structured log ingest with Loki-compatible query API
-- **Alerts** — runtime alerts for delivery failures, errors, and service health
-- **Dashboard** — realtime web UI for traces, events, workflows, jobs, DLQ, service map, and service keys
+await sb.start();
 
----
+const res = await payment.Charge({ userId: "u-1", amount: 100 });
+// res.ok === true
+```
 
-## How It Compares
-
-| Concern | Istio + Envoy | Dapr | Temporal + Kafka | ServiceBridge |
-|---|---|---|---|---|
-| RPC data path | Sidecar proxy hop | Sidecar/daemon hop | N/A | **Direct (proxyless)** |
-| Service discovery | K8s control plane | Sidecar placement | External registry | **Built-in registry** |
-| Durable events + DLQ | External broker | Pub/Sub component | Kafka + consumers | **Built-in** |
-| Workflow orchestration | External engine | External engine | Built-in | **Built-in** |
-| Job scheduling | External cron/queue | External scheduler | External scheduler | **Built-in** |
-| Traces + UI | Jaeger/Tempo + dashboards | OTEL backend + dashboards | Temporal UI | **Built-in** |
-| Logs for Grafana | Loki + Promtail pipeline | Log pipeline | Log pipeline | **Built-in Loki API** |
-| Metrics | App/exporter setup | App/exporter setup | Multiple exporters | **Built-in `/metrics`** |
-| Security model | Mesh PKI + policy | Deployment-dependent mTLS | Mixed | **Service keys + auto mTLS** |
-| Operational footprint | Multi-component mesh | Runtime + sidecars | Workflow + broker + DB | **One binary + PostgreSQL** |
+Declare dependencies and build typed clients **before** `start()` — they ride along in the first registration. Calls succeed once `start()` has connected.
 
 ---
 
-## API Reference
-
-### Cross-SDK parity notes
-
-ServiceBridge keeps the core API shape consistent across Node.js, Go, and Python:
-constructor, RPC, events, jobs, workflows, `executeWorkflow`, streams, serve/stop, and `ServiceBridgeError`.
-
-Constructor-level defaults for `timeout`, `retries`, and `retryDelay` are available
-across all three SDKs. Parity differences are naming-only (language idioms):
-
-- Constructor TLS overrides: `workerTLS`/`caCert` (Node), `WorkerTLS`/`CACert` (Go), `worker_tls`/`ca_cert` (Python)
-- Handler hints: timeout/retryable/concurrency/prefetch are advisory in all SDKs
-- Shared `serve()` fields across SDKs: host, max in-flight, instance ID, weight, and per-serve TLS override
+## Runtime setup
 
-### `servicebridge(url, serviceKey, opts?)`
+The SDK needs a running ServiceBridge runtime. Spin one up with the one-line installer:
 
-```ts
-function servicebridge(
-  url: string,
-  serviceKey: string,
-  opts?: ServiceBridgeOpts,
-): ServiceBridgeService
+```sh
+bash <(curl -fsSL https://servicebridge.dev/install.sh)
 ```
 
-Creates an SDK client instance.
-Service identity is resolved by the runtime from `serviceKey`.
-
-`ServiceBridgeOpts`:
+It pulls the runtime container, wires it to PostgreSQL 18+, and exposes the gRPC control plane on `:14445` and the dashboard on `:14444`. Open the dashboard, create a service, and copy its **bootstrap service key** — that opaque string is the second argument to `new ServiceBridge(url, key)`.
 
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `timeout` | `number` | `30000` | Default hard timeout per RPC attempt (ms). |
-| `retries` | `number` | `3` | Default retry count for `rpc()`. |
-| `retryDelay` | `number` | `300` | Base backoff delay (ms) for `rpc()`. |
-| `discoveryRefreshMs` | `number` | `10000` | Discovery refresh period for endpoint updates. |
-| `queueMaxSize` | `number` | `1000` | Max offline queue size for control-plane writes. |
-| `queueOverflow` | `"drop-oldest" \| "drop-newest" \| "error"` | `"drop-oldest"` | Overflow strategy for offline queue. |
-| `heartbeatIntervalMs` | `number` | `10000` | Base heartbeat period for worker registrations. |
-| `captureLogs` | `boolean` | `true` | Forward `console.*` logs to ServiceBridge. |
+Each instance authenticates with its key: the SDK calls `Bootstrap.Provision`, receives a short-lived leaf certificate, opens an mTLS gRPC channel and registers. Certificates rotate automatically with overlap (the new session is live before the old one closes), so long-running instances never drop traffic at renewal.
 
-### Advanced TLS overrides
-
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `workerTLS` | `WorkerTLSOpts` | auto | Explicit cert/key/CA for worker mTLS. |
-| `caCert` | `string \| Buffer` | from `serviceKey` | Optional control-plane CA override. By default SDK reads CA from sbv2 service key. |
-
-`WorkerTLSOpts`:
-
-```ts
-type WorkerTLSOpts = {
-  caCert?: string | Buffer;
-  cert?: string | Buffer;
-  key?: string | Buffer;
-  serverName?: string;
-}
-```
+Full self-hosting docs live at **[servicebridge.dev/docs](https://servicebridge.dev/docs)**.
 
 ---
 
-### `rpc(service, fn, payload?, opts?)`
-
-```ts
-rpc<T = unknown>(service: string, fn: string, payload?: unknown, opts?: RpcOpts): Promise<T>
-```
+## End-to-end example
 
-Calls a registered RPC handler on another service. Direct gRPC path, no proxy.
+A small order flow: an HTTP request triggers a workflow that charges a payment, then publishes an event another service consumes — all traced as one tree.
 
-**Arguments** — `service` is the callee’s logical name; `fn` is the name used in `handleRpc` (e.g. `payment.charge`). Use **dot notation** in `fn` to group methods. Do not put `/` in `fn`.
+```ts
+import { ServiceBridge } from "service-bridge";
 
-`RpcOpts`:
+const sb = new ServiceBridge("localhost:14445", process.env.ORDERS_KEY!);
 
-| Option | Type | Description |
-|---|---|---|
-| `timeout` | `number` | Call timeout in ms. |
-| `retries` | `number` | Retry count override. |
-| `retryDelay` | `number` | Base retry delay override. |
-| `traceId` | `string` | Explicit trace id. |
-| `parentSpanId` | `string` | Explicit parent span id. |
-| `mode` | `"direct" \| "proxy"` | Transport mode. `"direct"` (default) connects directly to the worker. `"proxy"` routes through the control plane when direct connection is unavailable. |
+// Outgoing dependencies — declared before start().
+sb.service("payment-svc", { rpc: ["Charge"] });
+sb.event.define("order.placed", { protoFile: "./events.proto", input: "OrderPlaced" });
 
-```ts
-const user = await sb.rpc<{ id: string; name: string }>("users", "user.get", { id: "u_1" }, {
-  timeout: 5000,
-  retries: 2,
+// A durable workflow: charge, then announce. Steps run by dependency level.
+sb.workflow.handle("checkout", {
+  input: { type: "object", properties: { orderId: { type: "string" } } },
+  steps: [
+    { id: "charge", type: "call", service: "payment-svc", method: "Charge",
+      input: "$.input" },
+    { id: "announce", type: "publish", event: "order.placed",
+      input: "$.input", waitFor: ["charge"] },
+  ],
 });
-```
 
-`rpc()` is bounded even when a downstream worker is silent:
-each attempt has a hard local timeout, retries are finite (`retries + 1` total attempts),
-and after the final failed attempt the root RPC span is closed with `error`.
+sb.on("connected", ({ serviceName }) => console.log(`up as ${serviceName}`));
 
-Retry delay uses exponential backoff: `retryDelay * 2^(attempt-1)`.
+await sb.start();
 
----
-
-### `event(topic, payload?, opts?)`
-
-```ts
-event(topic: string, payload?: unknown, opts?: EventOpts): Promise<string>
+// Kick off a run and wait for the final state.
+const { runId } = await sb.workflow.start("checkout", { orderId: "o-1" });
+const state = await sb.workflow.await(runId);
+console.log("done", state);
 ```
 
-Publishes a durable event. Returns `messageId` when online.
-
-`EventOpts`:
-
-| Option | Type | Description |
-|---|---|---|
-| `traceId` | `string` | Explicit trace id. |
-| `parentSpanId` | `string` | Explicit parent span id. |
-| `idempotencyKey` | `string` | Idempotency key for dedup-safe publishing. |
-| `headers` | `Record<string, string>` | Custom metadata headers. |
+The consuming service just subscribes:
 
 ```ts
-await sb.event("orders.created", { orderId: "ord_42" }, {
-  idempotencyKey: "order:ord_42",
-  headers: { source: "checkout" },
+sb.event.handle("order.placed", async (payload) => {
+  await sendReceipt(payload);
 });
+await sb.start();
 ```
 
----
-
-### `publishEvent(topic, payload?, opts?)`
-
-```ts
-publishEvent(topic: string, payload?: unknown, opts?: PublishEventOpts): Promise<string>
-```
-
-Publishes an event via the established worker session stream. Requires an active worker session — call after `serve()`. Resolves with `messageId` once the server confirms with `publish_ack`. Times out after 30 s if no ack. Use `event()` when not serving (e.g. caller-only services); use `publishEvent()` from within a worker for lower-latency publishing over the existing session.
+In the dashboard you see one trace spanning the workflow run, the `Charge` RPC, the `order.placed` publish, and its delivery to the subscriber.
 
 ---
 
-### `job(target, opts)`
+## Platform features
 
-```ts
-job(target: string, opts: ScheduleOpts): Promise<string>
-```
+| Area | What you get |
+|---|---|
+| **Communication** | Direct RPC, server-side streaming, durable events, service discovery, full-mesh routing, a live service map |
+| **Orchestration** | Workflows (DAG steps with compensation), sub-workflows, jobs (cron / interval / delayed), bidirectional replay |
+| **Reliability** | At-least-once delivery, retries, DLQ, idempotency, fan-out, session resilience, multi-instance failover, circuit breakers |
+| **Traffic control** | Load balancing, rate limiting, per-definition limits, filter expressions, adaptive performance |
+| **Security** | TLS by default, mTLS identity, auto-provisioned certs from a service key, granular access policy |
+| **Observability** | Unified tracing with propagation, Prometheus-compatible metrics, structured logs, smart alerts |
 
-Registers a scheduled or delayed job.
+Designed to run up to 1000 services against a single runtime.
 
-`ScheduleOpts`:
-
-| Option | Type | Description |
-|---|---|---|
-| `cron` | `string` | Cron expression. |
-| `delay` | `number` | Delay in ms before execution. Backed by `int32` in the proto — maximum ~24.8 days (~2,147,483,647 ms). |
-| `timezone` | `string` | Timezone for cron execution. |
-| `misfire` | `"fire_now" \| "skip"` | Misfire policy. |
-| `via` | `"event" \| "rpc" \| "workflow"` | Target type. |
-| `retryPolicyJson` | `string` | Retry policy JSON string. |
+---
 
-```ts
-// RPC job: explicit service and function
-await sb.job("billing", "collect", {
-  cron: "0 * * * *",
-  timezone: "UTC",
-  via: "rpc",
-});
+## How it compares
 
-// Event job: single target
-await sb.job("user.signup", {
-  cron: "0 0 * * *",
-  via: "event",
-});
+| You'd otherwise reach for | ServiceBridge gives you |
+|---|---|
+| Istio / Linkerd (mesh, mTLS) | mTLS identity + routing + policy, no sidecars |
+| RabbitMQ / Kafka / NATS | Durable events with outbox, fan-out, retries, DLQ |
+| Temporal / Cadence | Durable workflows with compensation, signals, replay |
+| A cron service / Quartz | Leased, retried scheduled jobs |
+| Jaeger / Tempo + Prometheus + Loki | Tracing, metrics and logs, correlated out of the box |
+| gRPC + a service registry | Typed RPC with discovery, LB and breakers |
 
-// Workflow job: single target
-await sb.job("monthly_report", {
-  cron: "0 0 1 * *",
-  via: "workflow",
-});
-```
+The point isn't that ServiceBridge beats each tool at its own game — it's that you stop running and correlating ten of them.
 
 ---
 
-### `workflow(name, steps, opts?)`
+## API reference
 
-```ts
-workflow(name: string, steps: WorkflowStep[], opts?: WorkflowOpts): Promise<string>
-```
-
-Registers (or updates) a workflow definition as a DAG of typed steps. Returns the workflow name.
+The bridge exposes four domains (`sb.rpc`, `sb.event`, `sb.job`, `sb.workflow`) plus `sb.stream()` and `sb.telemetry`. Register handlers and declare dependencies **before** `start()`.
 
-`WorkflowStep`:
-
-| Field | Type | Description |
-|---|---|---|
-| `id` | `string` | Unique step identifier in the DAG. |
-| `type` | `"rpc" \| "event" \| "event_wait" \| "sleep" \| "workflow"` | Step execution type. |
-| `service` | `string` | **Required** for `rpc` and `workflow` steps. Target logical service name (e.g. `"inventory"`, `"payments"`). |
-| `ref` | `string` | Required for `rpc`, `event`, `event_wait`, `workflow`. For `rpc` — the registered function name (e.g. `"stock.reserve"`, `"payment.charge"`). For `event`/`event_wait` — topic or pattern. For `workflow` — child workflow name. Always use dots, never slashes. |
-| `deps` | `string[]` | Dependencies. Empty/omitted means root step. |
-| `if` | `string` | Optional filter expression (step is skipped if false). |
-| `timeoutMs` | `number` | Optional timeout for `rpc` and `event_wait` steps. |
-| `durationMs` | `number` | Required for `sleep` steps. |
+### RPC
 
-`WorkflowOpts`:
+`sb.rpc` is request/response: register handlers, call other services.
 
 ```ts
-interface WorkflowOpts {
-  stateLimitBytes?: number; // default 262144 (256 KB)
-  stepTimeoutMs?: number;   // default 30000 (30 s)
-}
-```
-
-| Field | Type | Default | Description |
-|---|---|---|---|
-| `stateLimitBytes` | `number` | `262144` (256 KB) | Maximum serialized state size in bytes. |
-| `stepTimeoutMs` | `number` | `30000` (30 s) | Default per-step timeout in milliseconds. |
+// Unary handler: (req) => res
+sb.rpc.handle<ChargeRequest, ChargeReply>(
+  "Charge",
+  async (req) => ({ ok: req.amount > 0 }),
+  { schema: { protoFile: "./payment.proto" } },
+);
 
-```ts
-await sb.workflow("order.fulfillment", [
-  { id: "reserve", type: "rpc", service: "inventory", ref: "stock.reserve" },
-  { id: "charge", type: "rpc", service: "payments", ref: "payment.charge", deps: ["reserve"] },
-  { id: "wait_5m", type: "sleep", durationMs: 300_000, deps: ["charge"] },
-  { id: "notify", type: "event", ref: "orders.fulfilled", deps: ["wait_5m"] },
-]);
+// Server-side streaming handler: (req) => AsyncIterable<chunk>
+sb.rpc.handleStream<GenRequest, Token>(
+  "Generate",
+  async function* (req) {
+    for (const word of req.prompt.split(" ")) yield { token: word };
+  },
+  { schema: { protoFile: "./gen.proto" } },
+);
 ```
 
-With explicit limits:
+Calling — the typed proxy from `sb.client()` (preferred), or the lower-level `sb.rpc.call()`:
 
 ```ts
-await sb.workflow("checkout.flow", steps, { stepTimeoutMs: 60_000 });
-```
-
----
-
-### `executeWorkflow(service, name, input?, opts?)`
+const res = await payment.Charge({ userId: "u-1", amount: 100 });
 
-```ts
-executeWorkflow(service: string, name: string, input?: unknown, opts?: ExecuteWorkflowOpts): Promise<{ traceId: string; groupTraceId: string }>
+const res2 = await sb.rpc.call("payment-svc", "Charge",
+  { userId: "u-1", amount: 100 },
+  { timeout: "5s", idempotencyKey: "order-42" },
+);
 ```
 
-Starts a workflow execution on demand. The workflow must be registered first via `workflow()` on the target service.
-An alternative to scheduling via `job(target, { via: "workflow" })` — triggers the execution immediately.
+`CallOpts` apply per call, layered over `callDefaults` from the constructor:
 
-| Parameter | Type | Default | Description |
+| `CallOpts` | Type | Default | Description |
 |---|---|---|---|
-| `service` | `string` | required | Logical service that owns the workflow definition (same as the worker identity that called `workflow()`). |
-| `name` | `string` | required | Workflow name. |
-| `input` | `unknown` | `undefined` | Optional JSON-serializable input payload. |
-
-Returns `{ traceId, groupTraceId }`. Use `traceId` with `watchTrace()` to observe execution in real time.
-
-`ExecuteWorkflowOpts`:
-
-| Option | Type | Description |
-|---|---|---|
-| `traceId` | `string` | Override trace ID for this workflow execution. |
-
-```ts
-const { traceId, groupTraceId } = await sb.executeWorkflow("users", "user.onboarding", { userId: "u_123" });
-```
+| `timeout` | `string` | `"30s"` | Deadline, e.g. `"500ms"`, `"10s"`, `"2m"`. |
+| `requestId` | `string` | random UUID v4 | Correlation id carried to the callee. |
+| `transport` | `"direct" \| "proxy" \| "auto"` | `"auto"` | `direct` = caller→callee mTLS; `proxy` = via the runtime; `auto` = direct when an endpoint is known. |
+| `idempotencyKey` | `string` | none | Opts into runtime-side dedup; replays within the TTL return the cached response. |
+| `retry` | `Partial<RetryOpts>` | exp. backoff | `{ maxAttempts: 3, baseDelayMs: 200, factor: 2, maxDelayMs: 5000, jitter: 0.3 }`. Set `maxAttempts: 1` to disable. |
 
----
-
-### `cancelWorkflow(traceId)`
+Without an `idempotencyKey`, ambiguous failures (`INTERNAL` / `ABORTED` / `UNKNOWN`) are treated as non-retryable so a non-idempotent call is never silently repeated. Schema-version mismatches are filtered at routing time, so blue-green deploys route `v1→v1` and `v2→v2` automatically.
 
-```ts
-cancelWorkflow(traceId: string): Promise<void>
-```
+### Events
 
-Cancels a running workflow instance.
+Durable, at-least-once publish/subscribe. Events hit a local SQLite outbox first, then drain to the runtime, so a publish survives a transient disconnect.
 
 ```ts
-await sb.cancelWorkflow("trace_01HQ...XYZ");
-```
-
----
-
-### `handleRpc(fn, handler, opts?)`
-
-```ts
-handleRpc(
-  fn: string,
-  handler: (payload: unknown, ctx?: RpcContext) => unknown | Promise<unknown>,
-  opts?: HandleRpcOpts,
-): ServiceBridgeService
-```
+// Declare what you publish (same file-based SchemaSpec as RPC).
+sb.event.define("order.placed", { protoFile: "./events.proto", input: "OrderPlaced" });
 
-Registers an RPC handler. Chainable.
-
-`RpcContext`:
-
-| Field | Type | Description |
-|---|---|---|
-| `traceId` | `string` | Current trace ID. |
-| `spanId` | `string` | Current span ID. |
-| `stream` | `StreamWriter` | Real-time stream writer. |
-
-`HandleRpcOpts`:
-
-| Option | Type | Description |
-|---|---|---|
-| `timeout` | `number` | Advisory timeout hint (currently metadata-level, not hard-enforced by runtime). |
-| `retryable` | `boolean` | Advisory retry hint (currently metadata-level, not a strict policy switch). |
-| `concurrency` | `number` | Advisory concurrency hint (currently not hard-enforced). |
-| `schema` | `RpcSchemaOpts` | Inline protobuf schema for binary encode/decode. |
-| `allowedCallers` | `string[]` | Allow-list of caller service names. |
-
-```ts
-sb.handleRpc("ai.generate", async (payload: { prompt: string }, ctx) => {
-  await ctx?.stream.write({ token: "Hello" }, "output");
-  await ctx?.stream.write({ token: " world" }, "output");
-  return { text: "Hello world" };
+// Subscribe — exact name or wildcard ("order.*", "order.#").
+sb.event.handle("order.placed", async (payload) => {
+  await fulfil(payload);
 });
-```
 
-`StreamWriter`:
-
-| Method | Signature | Description |
-|---|---|---|
-| `write` | `write(data: unknown, key?: string): Promise<void>` | Append a real-time chunk to the trace stream. |
-| `end` | `end(key?: string): Promise<void>` | No-op placeholder for API symmetry (lifecycle managed by runtime). |
+await sb.start();
 
----
-
-### `handleEvent(pattern, handler, opts?)`
-
-```ts
-handleEvent(
-  pattern: string,
-  handler: (payload: unknown, ctx: EventContext) => void | Promise<void>,
-  opts?: HandleEventOpts,
-): ServiceBridgeService
+const { eventId } = await sb.event.publish("order.placed", { orderId: "o-1", total: 4200 });
 ```
 
-Registers an event consumer handler. Chainable.
-
-`HandleEventOpts`:
+Event names must match `^[a-z0-9_-]+(\.[a-z0-9_-]+)*$` (invalid → `InvalidEventNameError`). A full outbox throws `OutboxFullError`.
 
-| Option | Type | Description |
+| `PublishOpts` | Type | Description |
 |---|---|---|
-| `concurrency` | `number` | Advisory concurrency hint (currently not hard-enforced). |
-| `prefetch` | `number` | Advisory prefetch hint (currently not hard-enforced). |
-| `retryPolicyJson` | `string` | Retry policy JSON string. |
-| `filterExpr` | `string` | Server-side filter expression. |
+| `idempotencyKey` | `string` | Dedup key for at-least-once delivery. |
+| `partitionKey` | `string` | Orders delivery within a partition. |
+| `fireAndForget` | `boolean` | Skip the durable wait for the publish ack. |
+| `headers` | `Record<string, string>` | Custom envelope headers. |
+| `occurredAtMs` | `number` | Event time (unix-ms); defaults to now. |
 
-Duplicate pattern registration within the same service throws an error.
+The runtime delivers at-least-once, retries failures, fans out to every matching subscriber, and dead-letters exhausted messages. The DLQ is operated from the dashboard — the SDK has no DLQ API; make handlers idempotent and throw to signal "retry me".
 
-**Delivery guarantee**: once a message is accepted by the runtime, delivery to each consumer group
-is guaranteed. If the consumer is offline, the message waits in the server-side queue and is
-dispatched automatically the moment the service reconnects and registers its handlers — no retry
-budget is consumed while waiting. After `SERVICEBRIDGE_DELIVERY_TTL_DAYS` (default 7) days without
-a consumer, the delivery moves to DLQ with reason `delivery_ttl_exceeded`.
+### Jobs
 
-`EventContext` helpers:
-
-- `ctx.traceId` — current trace ID
-- `ctx.spanId` — current span ID
-- `ctx.retry(delayMs?)` — ask for redelivery with optional delay
-- `ctx.reject(reason)` — move to DLQ immediately, bypassing remaining retries
-- `ctx.refs` — metadata (`topic`, `groupName`, `messageId`, `attempt`, `headers`)
-- `ctx.stream.write(...)` — append real-time chunks to trace stream
+Scheduled work: cron, fixed interval, or one-shot delay. The runtime owns the schedule, leasing and retries.
 
 ```ts
-sb.handleEvent("orders.*", async (payload, ctx) => {
-  const body = payload as { orderId?: string };
-  if (!body.orderId) {
-    ctx.reject("missing_order_id");
-    return;
-  }
-  await ctx.stream.write({ status: "processing", orderId: body.orderId }, "progress");
-});
-```
-
----
+sb.job.handle("nightly-rollup",
+  { trigger: { cron: "0 3 * * *", tz: "UTC" } },     // 5-field cron, no seconds
+  async (ctx) => { await rollup(ctx.scheduledAt); },
+);
 
-### `serve(opts?)`
+sb.job.handle("heartbeat", { trigger: { interval: 30_000 } }, async () => { await ping(); });
 
-```ts
-serve(opts?: ServeOpts): Promise<void>
+sb.job.handle("send-reminder",
+  { trigger: { delayed: { at: Date.now() + 60_000 } } }, // Date | number | ISO string
+  async (ctx) => { await remind(ctx.idempotencyKey); },
+);
 ```
 
-Starts the worker gRPC server and registers handlers with the control plane.
-The promise resolves once startup/registration is complete (it does not block
-the Node.js process). Throws immediately if no handlers are registered (neither `handleRpc()` nor `handleEvent()` have been called).
-
-`ServeOpts`:
+The handler receives a `JobHandlerCtx`: `{ jobName, executionId, scheduledAt, localScheduledAt, attempt, idempotencyKey, signal }`.
 
-| Option | Type | Description |
-|---|---|---|
-| `host` | `string` | Bind host. Default: `localhost`. Use `0.0.0.0` in Docker/Kubernetes so ServiceBridge can reach the worker. |
-| `maxInFlight` | `number` | Max in-flight runtime-originated commands over `OpenWorkerSession`. Default: `128`. |
-| `instanceId` | `string` | Stable worker instance identifier. |
-| `weight` | `number` | Scheduling/discovery weight hint. |
-| `tls` | `WorkerTLSOpts` | Per-serve worker TLS override. |
-
-```ts
-await sb.serve({
-  host: "localhost",
-  instanceId: process.env.HOSTNAME,
+| `JobOpts` | Type | Default | Description |
+|---|---|---|---|
+| `trigger` | `{cron, tz?} \| {delayed:{at}} \| {interval}` | required | Exactly one trigger; `interval` is in ms. |
+| `catchup` | `"skip" \| "fire_once" \| "fire_all"` | `skip` | What to do for fire times missed during downtime. |
+| `overlap` | `"skip" \| "allow" \| "buffer_one"` | `allow` | Behaviour when a previous run is still in flight. |
+| `deps` | `DeclaredDep[]` | none | Outgoing deps: `{ rpc }`, `{ event }`, `{ workflow }`. |
+| `maxAttempts` / `leaseTtlMs` / `maxConcurrent` / `retry` | — | runtime default | Execution limits and `{ initialMs, maxMs, multiplier, jitter }` retry. |
+
+### Workflows
+
+Durable DAGs. Declare the graph once; the runtime executes it, persists state between steps, survives restarts, and compensates on failure or cancel.
+
+```ts
+sb.workflow.handle("checkout", {
+  input: { type: "object", properties: { orderId: { type: "string" } } },
+  steps: [
+    { id: "reserve", type: "call", service: "inventory-svc", method: "Reserve",
+      input: "$.input",
+      compensate: { service: "inventory-svc", method: "Release", input: "$.reserve" } },
+    { id: "charge", type: "call", service: "payment-svc", method: "Charge",
+      input: "$.input", waitFor: ["reserve"] },
+    { id: "notify", type: "publish", event: "order.placed",
+      input: "$.input", waitFor: ["charge"] },
+  ],
 });
 ```
 
----
-
-### `stop()`
-
-```ts
-stop(): void
-```
-
-Gracefully stops the worker gRPC server (try graceful shutdown, then force), heartbeats, channels, and SDK internals.
-
----
+Top-level steps run in parallel by default; `waitFor` declares dependencies and defines the execution levels. Step types: `call`, `publish`, `sleep`, `wait_event`, `wait_signal`, `workflow` (sub-workflow), `parallel`, `sequence`, `local`. Inputs are JSON-path expressions (`"$.input"`, `"$.reserve.id"`) over the accumulated run state.
 
-### `startHttpSpan(opts)`
+Driving a run:
 
 ```ts
-startHttpSpan(opts: {
-  method: string;
-  path: string;
-  traceId?: string;
-  parentSpanId?: string;
-}): HttpSpan
-```
-
-Manual HTTP tracing primitive.
+const { runId } = await sb.workflow.start("checkout", { orderId: "o-1" });
 
-```ts
-const span = sb.startHttpSpan({ method: "GET", path: "/health" });
-try {
-  span.end({ statusCode: 200, success: true });
-} catch (e) {
-  span.end({ success: false, error: String(e) });
-}
+const state = await sb.workflow.await(runId);          // block until terminal
+const snap  = await sb.workflow.query(runId);          // { status, state, steps: [...] }
+await sb.workflow.signal(runId, "approval", { ok: 1 }); // resume a wait_signal step
+await sb.workflow.cancel(runId);                        // compensate in reverse
+const { runId: forked } = await sb.workflow.replay(runId, { fromStepId: "charge" });
 ```
 
----
-
-### `registerHttpEndpoint(opts)`
-
-```ts
-registerHttpEndpoint(opts: {
-  method: string;
-  route: string;
-  instanceId?: string;
-  endpoint?: string;
-  allowedCallers?: string[];
-  requestSchemaJson?: string;
-  responseSchemaJson?: string;
-  transport?: string;
-}): Promise<void>
-```
-
-Registers HTTP route metadata in the ServiceBridge service catalog.
-Also starts a periodic heartbeat to keep the HTTP endpoint alive in the registry.
-
-| Option | Type | Description |
-|---|---|---|
-| `method` | `string` | HTTP method: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, etc. |
-| `route` | `string` | Route pattern with parameter placeholders, e.g. `"/users/:id"`. |
-| `instanceId` | `string` | Stable identifier for this process instance. |
-| `endpoint` | `string` | Reachable address, e.g. `"http://10.0.0.1:3000"`. |
-| `allowedCallers` | `string[]` | Service names allowed to call (RBAC). |
-| `requestSchemaJson` | `string` | JSON schema for request validation metadata. |
-| `responseSchemaJson` | `string` | JSON schema for response validation metadata. |
-| `transport` | `string` | Transport label (e.g. `"http"`, `"https"`). |
-
-```ts
-await sb.registerHttpEndpoint({
-  method: "GET",
-  route: "/users/:id",
-  requestSchemaJson: '{"type":"object"}',
-  transport: "http",
-});
-```
-
----
-
-### `watchTrace(traceId, opts?)`
-
-```ts
-watchTrace(traceId: string, opts?: WatchTraceOpts): AsyncIterable<TraceStreamEvent>
-```
-
-Subscribes to a trace stream with replay and live updates. `traceId` is the stream
-identifier used by `ctx.stream.write(...)`.
-
-`WatchTraceOpts`:
-
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `key` | `string` | `""` | Stream key filter (`""` = all keys). |
-| `fromSequence` | `number` | `0` | Replay from sequence cursor. |
-
-`TraceStreamEvent`:
+Use `sb.workflow.query()` for the snapshot — there is no `getStatus`. `start()` with no permission throws `WorkflowAccessDeniedError`; an unknown name throws `WorkflowNotFoundError`; signalling/cancelling a finished run throws `WorkflowTerminalError`.
 
-| Field | Type | Description |
-|---|---|---|
-| `type` | `"chunk" \| "trace_complete"` | Event kind. |
-| `traceId` | `string` | Trace identifier being watched. |
-| `key` | `string` | Stream lane key. |
-| `sequence` | `number` | Monotonic sequence number. |
-| `data` | `unknown` | JSON-decoded chunk payload. |
-| `traceStatus` | `string \| undefined` | Final status on `trace_complete`. |
-
-Behavior:
+### Streaming
 
-- Auto-reconnect with exponential backoff (`500ms` → `5000ms`) on retryable stream failures.
-- Deduplicates by `sequence` across reconnects.
-- Enforces strict JSON for `type="chunk"` payloads (non-JSON chunk terminates stream with fatal error).
-- Enforces internal queue limit `256`; overflow is fatal (consumer must drain promptly).
+Server-side streaming is a first-class RPC shape. Register with `sb.rpc.handleStream`, consume with `sb.stream()` (or the typed proxy, which auto-detects `returns (stream T)` methods).
 
 ```ts
-for await (const evt of sb.watchTrace(traceId, { key: "output", fromSequence: 0 })) {
-  if (evt.type === "chunk") {
-    process.stdout.write(String((evt.data as { token?: string }).token ?? ""));
-  }
-  if (evt.type === "trace_complete") break;
+for await (const chunk of sb.stream("gen-svc", "Generate", { prompt: "write a haiku" })) {
+  process.stdout.write(chunk.token);
 }
 ```
 
----
-
-### Trace Utilities
-
-#### `getTraceContext()`
+Breaking the loop (`break`/`return`) tears down the gRPC stream end to end. Streams are single-pick — never retried — by design.
 
-```ts
-getTraceContext(): { traceId: string; spanId: string } | undefined
-```
+### Telemetry
 
-Returns the current async-local trace context.
+Telemetry flows automatically: every RPC, event, job, workflow step and HTTP request emits an operation span and propagates the trace across hops. Add your own through `sb.telemetry`; anything emitted inside a handler nests under that handler's trace.
 
 ```ts
-import { getTraceContext } from "service-bridge";
+import { Channel, UserSubOp } from "service-bridge";
 
-const tc = getTraceContext();
-if (tc) {
-  console.log(tc.traceId, tc.spanId);
+const op = sb.telemetry.startOp({
+  channel: Channel.USER, kind: UserSubOp, subject: "reprice-cart", businessKey: cartId,
+});
+try {
+  await reprice(cartId);
+  op.end(/* Status.SUCCESS */);
+} catch (err) {
+  op.end(/* Status.ERROR */, String(err));
+  throw err;
 }
-```
 
-#### `withTraceContext(ctx, fn)`
-
-```ts
-withTraceContext<T>(ctx: { traceId: string; spanId: string }, fn: () => T): T
+sb.telemetry.log.info("cart repriced", { cartId, items: 7 }); // also sb.logger
+sb.telemetry.counter("carts_repriced_total").inc();
+sb.telemetry.gauge("queue_depth").set(42);
+sb.telemetry.histogram("reprice_ms", "ms").observe(12.5);
 ```
 
-Runs a function inside an explicit trace context.
+`startOp()` returns a handle whose `.end(status, message?)` closes the span. Anything emitted before `start()` buffers in an in-memory ring and drains once connected.
 
-```ts
-import { withTraceContext } from "service-bridge";
+### HTTP
 
-withTraceContext({ traceId: "trace-1", spanId: "span-1" }, async () => {
-  await sb.event("audit.log", { action: "user.login" });
-});
-```
+ServiceBridge does **not** proxy your business HTTP. You run your own server; the integration discovers your routes, publishes them to the Service Map, and wraps each request in a trace span so HTTP stitches into the same trace as the RPCs and events it triggers. See [HTTP plugins](#http-plugins).
+
+Useful read accessors after `start()`: `sb.identity()` (current session identity or `null`), `sb.serviceMap()` (live registry: visible methods, instances, endpoints), `sb.policyEvaluation()` (the runtime's current access-policy verdict).
 
 ---
 
-## HTTP Plugins
+## HTTP plugins
 
-### Express (`service-bridge/express`)
+Each integration is a subpath import with an optional peer dependency.
 
-```bash
-npm install express
-```
+**Express** — `service-bridge/express`:
 
 ```ts
 import express from "express";
-import { servicebridge } from "service-bridge";
-import { servicebridgeMiddleware, registerExpressRoutes } from "service-bridge/express";
+import { ServiceBridge } from "service-bridge";
+import { attachExpress } from "service-bridge/express";
 
-const sb = servicebridge(process.env.SERVICEBRIDGE_URL!, process.env.SERVICEBRIDGE_SERVICE_KEY!);
 const app = express();
+app.post("/orders", (req, res) => res.json({ ok: true }));
 
-app.use(servicebridgeMiddleware({
-  client: sb,
-  excludePaths: ["/health"],
-  autoRegister: true,
-}));
+const sb = new ServiceBridge("localhost:14445", KEY);
+await sb.start();
 
-app.get("/users/:id", async (req, res) => {
-  const user = await req.servicebridge.rpc("users", "user.get", { id: req.params.id });
-  res.json(user);
-});
+app.listen(3000, () => attachExpress(app, sb, { port: 3000 }));
 ```
 
-#### `servicebridgeMiddleware(options)`
-
-```ts
-servicebridgeMiddleware(options: {
-  client: ServiceBridgeService;
-  excludePaths?: string[];
-  propagateTraceHeader?: boolean;
-  autoRegister?: boolean;
-}): express.RequestHandler
-```
-
-- Attaches `req.servicebridge`, `req.traceId`, `req.spanId`
-- Starts/ends HTTP span automatically
-- Optionally sets `x-trace-id` response header
-- Optionally auto-registers route pattern in catalog on first hit
-
-#### `registerExpressRoutes(app, client, opts?)`
-
-Eager route catalog registration without waiting for first request.
-
-```ts
-await registerExpressRoutes(app, sb, {
-  endpoint: "http://10.0.0.5:3000",
-  allowedCallers: ["api-gateway"],
-  excludePaths: ["/health"],
-});
-```
-
----
-
-### Fastify (`service-bridge/fastify`)
-
-```bash
-npm install fastify
-```
+**Fastify** — `service-bridge/fastify`:
 
 ```ts
 import Fastify from "fastify";
-import { servicebridge } from "service-bridge";
-import { servicebridgePlugin, wrapHandler } from "service-bridge/fastify";
+import { ServiceBridge } from "service-bridge";
+import { sbFastify } from "service-bridge/fastify";
 
-const sb = servicebridge(process.env.SERVICEBRIDGE_URL!, process.env.SERVICEBRIDGE_SERVICE_KEY!);
 const app = Fastify();
+const sb = new ServiceBridge("localhost:14445", KEY);
 
-await app.register(servicebridgePlugin, {
-  client: sb,
-  excludePaths: ["/health"],
-  autoRegister: true,
-});
+app.post("/orders", async () => ({ ok: true }));
+await app.register(sbFastify, { sb }); // discovers routes + endpoint in onListen
 
-app.get("/users/:id", wrapHandler(async (request, reply) => {
-  const user = await request.servicebridge.rpc("users", "user.get", {
-    id: (request.params as any).id,
-  });
-  return reply.send(user);
-}));
+await sb.start();
+await app.listen({ port: 3000 });
 ```
 
-#### `servicebridgePlugin(fastify, options)`
+**Hono** — `service-bridge/hono`:
 
 ```ts
-servicebridgePlugin(fastify, {
-  client,
-  excludePaths?,
-  propagateTraceHeader?,
-  autoRegister?,
-  register?: {
-    instanceId?,
-    endpoint?,
-    allowedCallers?,
-    excludePaths?,
-  },
-})
-```
-
-- Decorates `request.servicebridge`, `request.traceId`, `request.spanId`
-- Traces HTTP lifecycle via hooks
-- Auto-registers routes on `onRoute` before traffic
+import { Hono } from "hono";
+import { ServiceBridge } from "service-bridge";
+import { attachHono } from "service-bridge/hono";
 
-#### `wrapHandler(handler)`
+const app = new Hono();
+app.post("/orders", (c) => c.json({ ok: true }));
 
-Runs a Fastify handler inside the current trace context so downstream SDK calls inherit the trace.
-
----
+const sb = new ServiceBridge("localhost:14445", KEY);
+await sb.start();
 
-### Trace Utilities (HTTP Plugins)
-
-#### `extractTraceFromHeaders(headers)`
-
-```ts
-import { extractTraceFromHeaders } from "service-bridge/express";
-// or
-import { extractTraceFromHeaders } from "service-bridge/fastify";
-
-const { traceId, parentSpanId } = extractTraceFromHeaders(req.headers);
+attachHono(app, sb, { port: 3000 }); // Hono doesn't own the socket — pass the port
+Bun.serve({ port: 3000, fetch: app.fetch });
 ```
 
-Extracts trace context from HTTP headers. Supports W3C `traceparent`, `x-trace-id`/`x-span-id` headers, and generates random IDs as fallback. Useful for custom HTTP framework integrations (Hono, Koa, etc.).
+`attachExpress`/`attachHono` take `{ port, host? }`; `sbFastify` reads the bound address itself. Host defaults to the bound socket, falling back to `127.0.0.1`. Attaching before `start()` is safe — the endpoint rides along in the first registration.
 
 ---
 
 ## Configuration
 
-### TLS behavior
-
-- Worker transport is TLS-only.
-- Control plane is TLS-only. Trust source is embedded into sbv2 service key by default.
-- Embedded/explicit CA PEM is validated with strict x509 parsing.
-- If `workerTLS` is not provided, SDK auto-provisions worker certs via gRPC `ProvisionWorkerCertificate`.
-- `workerTLS.cert` and `workerTLS.key` must be provided together.
-- `serve({ tls })` overrides global `workerTLS` for a specific worker instance.
-
-### Offline queue behavior
-
-When the control plane is unavailable, SDK queues write operations (`event`, `job`, `workflow`, telemetry writes).
-
-- Queue size: `queueMaxSize` (default: 1000)
-- Overflow policy: `queueOverflow` (default: `"drop-oldest"`)
-- Return values for queued writes may be empty strings until flushed
-
----
-
-## Environment Variables
+All configuration lives on the `ServiceBridge` constructor — `new ServiceBridge(url, key, options)`. The SDK reads no environment variables; you decide where `url`, `key` and options come from. Every option is optional.
 
-The SDK requires values you pass into `servicebridge(...)`. Common setup:
-
-| Variable | Required | Example | Description |
+| Option | Type | Default | Description |
 |---|---|---|---|
-| `SERVICEBRIDGE_URL` | yes | `localhost:14445` | gRPC control plane URL |
-| `SERVICEBRIDGE_SERVICE_KEY` | yes | `sbv2.<id>.<secret>.<ca>` | Service authentication key (sbv2 only) |
-
-```ts
-const sb = servicebridge(
-  process.env.SERVICEBRIDGE_URL ?? "localhost:14445",
-  process.env.SERVICEBRIDGE_SERVICE_KEY!,
-);
-```
-
----
-
-## Error Handling
-
-`ServiceBridgeError` is exported for normalized SDK and runtime errors.
-
-```ts
-import { servicebridge, ServiceBridgeError } from "service-bridge";
-
-try {
-  await sb.rpc("payments", "payment.charge", { orderId: "ord_1" });
-} catch (e) {
-  if (e instanceof ServiceBridgeError) {
-    console.error(e.component, e.operation, e.severity, e.retryable, e.code);
-  }
-  throw e;
-}
-```
-
-| Field | Type | Description |
-|---|---|---|
-| `component` | `string` | SDK subsystem (for example, `"rpc"` or `"event"`). |
-| `operation` | `string` | Operation that failed. |
-| `severity` | `"fatal" \| "retriable" \| "ignorable"` | Error classification. |
-| `retryable` | `boolean` | Whether retry is recommended. |
-| `code` | `number \| undefined` | gRPC status code (if available). |
-| `cause` | `unknown` | Original underlying error. |
-
----
-
-## When to Use / When Not to Use
-
-### ServiceBridge is a good fit when you:
-
-- Have **3+ microservices** that need to communicate via RPC, events, or both
-- Want **RPC + events + workflows + jobs** without managing separate infrastructure for each
-- Need **end-to-end tracing** across all communication patterns in one timeline
-- Want to **eliminate sidecar proxies** and reduce operational overhead
-- Need **durable event delivery** with retry, DLQ, and replay without running a broker
-- Are building **AI/LLM pipelines** and need realtime streaming with replay
-
-### Consider alternatives when you:
-
-- Run a **single monolith** with no service decomposition plans
-- Need **ultra-high-throughput event streaming** (100K+ msg/s sustained) — Kafka is purpose-built for this
-- Need a **full API gateway** with rate limiting, auth plugins, and request transformation — use Kong/Envoy Gateway
-- Already have a **mature Istio/Linkerd mesh** and only need traffic management (no events/workflows/jobs)
-- Need **multi-region event replication** — ServiceBridge currently targets single-region deployments
-
----
-
-## v2 Session API
-
-`session_v2.ts` реализует новый Enterprise Session Protocol — Channel-based bidi stream с 8-состоянийным FSM, адаптивным heartbeat и кредитным управлением потоком. Симметричен с Go и Python SDK.
-
-### Жизненный цикл сессии (8 состояний FSM)
-
-```
-connecting → handshaking → ready ↔ active
-                                 ↘ suspended → (reconnect)
-                                 ↘ draining → closed
-                                 ↘ fenced   (permanent)
-```
-
-| Состояние | Описание |
-|-----------|----------|
-| `connecting` | Устанавливается TCP/TLS соединение |
-| `handshaking` | Отправлен Hello, ждём HelloAck |
-| `ready` | HelloAck получен, команды не выполняются |
-| `active` | Есть активные команды |
-| `suspended` | Heartbeat пропущен 2+ раза |
-| `draining` | Инициирован graceful shutdown |
-| `fenced` | Сервер прислал GOAWAY_FENCED — сессия закрыта навсегда |
-| `closed` | Соединение закрыто |
-
-### Быстрый старт
-
-```typescript
-import { V2SessionClient, validateV2Config } from 'service-bridge';
-
-const cfg = {
-  serverAddress: 'localhost:9090',
-  instanceId: 'worker-1',
-  zone: 'us-east-1a',
-  transportMode: 'direct' as const,
-  maxInflight: 64,
-};
-
-validateV2Config(cfg);
-const session = new V2SessionClient(cfg);
-
-// Отправить Hello при подключении
-const hello = session.getHelloFields();
-
-// Обработать HelloAck от сервера
-session.onHelloAck({
-  sessionId: 'sess-abc',
-  resumeToken: 'token-xyz',
-  epoch: 1n,
-  resumed: false,
-  resumeFromSeq: 0n,
-  replayedCommands: 0,
-  reconciledResults: 0,
-  heartbeatIntervalMs: 10_000,
-  heartbeatTimeoutMs: 30_000,
-  initialPermits: 64,
-  maxPermits: 128,
-  effectiveTransportMode: 'direct',
+| `advertise` | `{ host, port } \| false` | `127.0.0.1` on a free port (with a warning) | Inbound RPC server address. Pass `{ host, port }` in containers / k8s; `false` for caller-only instances that never serve RPC. |
+| `callDefaults` | `CallOpts` | `{}` | Default `CallOpts` merged under every `sb.rpc.call()` / `sb.stream()`. |
+| `failOnPolicyViolation` | `boolean` | `false` | When `true`, any policy warning at registration makes `start()` surface a `disconnected` event and stop. Otherwise warnings are logged and emitted as `policy_violation`. |
+| `telemetry` | `boolean` | `true` | Emit ops/logs/metrics to the runtime. `false` fully disables the telemetry transport. |
+| `telemetryRingSize` | `number` | `262144` (256 KiB) | Byte budget for the in-memory ops ring buffer. |
+| `dataDir` | `string` | `"./.servicebridge"` | Directory for the local SQLite event outbox. |
+| `maxOutboxRows` | `number` | `100000` | Outbox rows before `publish` back-pressures with `OutboxFullError`. |
+| `eventsDrainerBatch` | `number` | `50` | Outbox rows drained to the runtime per tick. |
+| `eventsMaxInFlight` | `number` | `32` | Max concurrent inbound events processed by subscribers. |
+| `payloadMaxBytes` | `number` | `65536` | Per-direction cap on captured payload bytes. |
+| `reconnectIntervalMs` | `number` | `3000` | Delay between reconnect attempts. |
+| `reconnectAttempts` | `number` | `3` | Reconnect attempts before giving up. `0` = unlimited. |
+
+```ts
+const sb = new ServiceBridge("localhost:14445", KEY, {
+  advertise: { host: process.env.POD_IP!, port: 50051 },
+  callDefaults: { timeout: "10s" },
+  reconnectAttempts: 0,
+  dataDir: "/var/lib/myservice/sb",
 });
-
-console.log(session.state); // 'ready'
-
-// Входящая команда
-const accepted = session.onCommandReceived(1n, 'cmd-001');
-if (!accepted) {
-  // backpressure — permits = 0
-}
-
-// Команда выполнена
-session.onCommandCompleted(1n, 'cmd-001');
 ```
 
-### Адаптивный heartbeat (EWMA RTT)
-
-```typescript
-import { AdaptiveHeartbeatV2 } from 'service-bridge';
-
-const hb = new AdaptiveHeartbeatV2(10_000, 30_000);
-
-// Получен pong
-hb.onPong(25); // rttMs
-
-// Следующий интервал (адаптируется по EWMA RTT)
-const nextMs = hb.nextIntervalMs();
+### Lifecycle
 
-// Пропуск — ускоряем пинги
-const missCount = hb.onMiss();
-if (missCount >= 2) {
-  // reconnect
-}
-```
-
-Алгоритм: базовый интервал `intervalMs / 3`; при пропусках делится на `2^miss` (min 2s); при стабильном RTT < 50ms удваивается (max 30s).
-
-### Кредитное управление потоком
-
-```typescript
-import { FlowControlStateV2 } from 'service-bridge';
+```ts
+const sb = new ServiceBridge("localhost:14445", KEY);
 
-const fc = new FlowControlStateV2(64, 1, 128);
+sb.service("payment-svc", { rpc: ["Charge"] });               // what you call
+sb.rpc.handle("Ship", shipHandler, { schema: { protoFile: "./ship.proto" } }); // what you serve
 
-if (fc.tryConsume()) {
-  // dispatch command
-}
+sb.on("connected",      ({ serviceName }) => console.log(`connected as ${serviceName}`));
+sb.on("reconnecting",   ({ attempt, reason }) => console.warn(`reconnecting #${attempt}: ${reason}`));
+sb.on("disconnected",   ({ reason }) => console.error(`disconnected: ${reason}`));
+sb.on("policy_violation", (v) => console.warn(`policy: ${v.declaration} ${v.value} — ${v.reason}`));
 
-// Команда завершена — вернуть permit
-fc.release(1);
+await sb.start();
 
-// Сервер прислал FlowControlUpdate
-fc.setWindow(32);
+process.on("SIGTERM", async () => { await sb.stop(); process.exit(0); });
 ```
 
-### Reconnect и resume
-
-`BackoffV2` реализует экспоненциальный backoff с full jitter (base=100ms, max=30s). При переподключении `getHelloFields()` автоматически включает `resumeToken`, `epoch`, `lastReceivedSeq`, `lastSentSeq`, `completedCommandIds` — сервер продолжит сессию с нужной позиции.
-
-```typescript
-import { BackoffV2 } from 'service-bridge';
+---
 
-const backoff = new BackoffV2();
+## Error handling
 
-while (true) {
-  if (backoff.isCircuitOpen()) break; // 10+ сбоев подряд
+Typed errors are exported from the package root, so you can `catch` precisely:
 
-  const delayMs = backoff.next();
-  await new Promise(r => setTimeout(r, delayMs));
+```ts
+import {
+  RpcAccessDeniedError,
+  WorkflowAccessDeniedError,
+  InvalidEventNameError,
+  OutboxFullError,
+  ServiceBridgeError,
+} from "service-bridge";
 
-  try {
-    // reconnect...
-    backoff.reset();
-  } catch {
-    backoff.recordFail();
+try {
+  await payment.Charge({ userId: "u-1", amount: 100 });
+} catch (err) {
+  if (err instanceof RpcAccessDeniedError) {
+    // denied by access policy: { serviceName, methodName, reason }
+  } else if (err instanceof ServiceBridgeError) {
+    // connection / provisioning failure with a typed .code
   }
 }
 ```
 
-### ConfigPush — динамическая конфигурация транспорта
-
-Сервер может в любой момент прислать `ConfigPush` с новыми правилами маршрутизации:
-
-```typescript
-session.onConfigPush({
-  defaultMode: 'direct',
-  serviceOverrides: {
-    'payment-svc': { mode: 'proxy', fallbackPolicy: 'fallback_to_direct' },
-  },
-  functionOverrides: {
-    'payment-svc.charge': { mode: 'proxy', timeoutMs: 5000 },
-  },
-});
-
-// Разрешить транспорт для функции
-const mode = session.resolveTransportMode('payment-svc.charge'); // 'proxy'
-```
-
-### Все события сессии
-
-| Метод | Описание |
-|-------|----------|
-| `getHelloFields()` | Поля для отправки Hello (первый + resume) |
-| `onHelloAck(ack)` | Обработка HelloAck от сервера |
-| `onCommandReceived(seq, id)` | Входящая команда; возвращает `false` при backpressure |
-| `onCommandCompleted(seq, id)` | Команда выполнена; освобождает permit |
-| `onPermitGrant(n)` | Сервер добавил `n` permits |
-| `onFlowControlUpdate(size, reason)` | Сервер изменил размер окна |
-| `onPong(rttMs)` | Получен pong; обновляет EWMA |
-| `onHeartbeatMiss()` | Таймаут pong; возвращает `true` → `suspended` |
-| `onDrain(reason, deadlineMs)` | Инициировать graceful drain |
-| `onGoaway(code, reason)` | GoawaySignal от сервера |
-| `onConfigPush(config)` | Применить новую конфигурацию транспорта |
-| `resolveTransportMode(fnName)` | Получить режим транспорта для функции |
-| `stop()` | Немедленно закрыть сессию |
-
-### Экспортируемые классы и типы
-
-| Символ | Тип | Описание |
-|--------|-----|----------|
-| `V2SessionClient` | class | Главный клиент сессии |
-| `AdaptiveHeartbeatV2` | class | EWMA RTT heartbeat controller |
-| `FlowControlStateV2` | class | Кредитное управление потоком |
-| `BackoffV2` | class | Exponential backoff + circuit |
-| `PositionTrackerV2` | class | Трекер seq/completed IDs |
-| `ConfigPushStateV2` | class | Менеджер динамической конфигурации |
-| `validateV2Config` | function | Валидация конфига; бросает `Error` |
-| `V2Config` | interface | Конфигурация сессии |
-| `SessionStateV2` | type | Союз 8 состояний FSM |
-| `TransportMode` | type | `'direct' \| 'proxy'` |
-| `HelloAckV2` | interface | Данные HelloAck от сервера |
-| `TransportConfigV2` | interface | ConfigPush payload |
-| `ReconcileRequestV2` | interface | Declarative worker registration request |
-| `FunctionDeclarationV2` | interface | Function declaration for Reconcile |
-| `ConsumerGroupDeclarationV2` | interface | Consumer group declaration |
-| `HttpRouteDeclarationV2` | interface | HTTP route declaration |
-| `JobDeclarationV2` | interface | Job declaration |
-| `WorkflowDeclarationV2` | interface | Workflow declaration |
-| `SubscribeRequestV2` | interface | Registry subscribe request |
-| `WorkerEndpointV2` | interface | Worker endpoint info |
-| `IssueCertificateRequestV2` | interface | Certificate request |
-| `IssueCertificateResponseV2` | interface | Certificate response |
-| `CircuitBreakerConfigV2` | interface | Circuit breaker config |
-| `ZoneConfigV2` | interface | Zone-aware config |
-| `ServiceTransportOverride` | interface | Per-service transport override |
-| `FunctionTransportOverride` | interface | Per-function transport override |
-| `ResumeState` | interface | Reconnect resume state |
-
-Key types available for import:
-
-```ts
-import type {
-  WorkflowStep,
-  WorkerTLSOpts,
-  RpcContext,
-  EventContext,
-  StreamWriter,
-  TraceCtx,
-  RetryPolicy,
-  ServiceBridgeErrorSeverity,
-} from "service-bridge";
-```
+| Error | Thrown when |
+|---|---|
+| `RpcAccessDeniedError` | An RPC call is denied by access policy. Also fires a `policy_violation` event. |
+| `WorkflowAccessDeniedError` | A workflow `start()` is denied by access policy. |
+| `WorkflowNotFoundError` | Starting a workflow name the runtime doesn't know. |
+| `WorkflowTerminalError` | Signalling/cancelling a run that already finished. |
+| `InvalidEventNameError` | Publishing/defining an event whose name fails the naming rule. |
+| `OutboxFullError` | The local event outbox is at `maxOutboxRows` (back-pressure). |
+| `ServiceBridgeError` | Connection / provisioning failures; carries a typed `.code` (retryable ones drive auto-reconnect). |
 
 ---
 
 ## FAQ
 
-**How does ServiceBridge handle service failures?**
-RPC calls have configurable retries with exponential backoff and hard per-attempt timeouts, so a silent downstream service cannot keep a call pending forever. Events are durable (PostgreSQL-backed) with at-least-once delivery per consumer group. Failed deliveries are retried according to policy, then moved to DLQ. Workflows track step state and can be resumed.
-
-**Is there vendor lock-in?**
-ServiceBridge is self-hosted. The runtime is a single Go binary + PostgreSQL. SDK calls map to standard patterns (RPC, pub/sub, cron) — migrating away means replacing SDK calls with equivalent library calls.
+**Do I have to use Protobuf?** You point handlers at a `.proto` file or a `.schema.json` with explicit field numbers. Both are file-based; there is no inline schema.
 
-**How does tracing work without an OTEL collector?**
-The SDK automatically reports trace spans for every RPC call, event publish/delivery, workflow step, and HTTP request. The runtime stores traces in PostgreSQL and serves them via the built-in dashboard and a Loki-compatible API for Grafana integration.
+**Does ServiceBridge proxy my HTTP traffic?** No. You run your own Express / Fastify / Hono server. The integration only discovers your routes for the Service Map and adds trace spans — your HTTP path is untouched.
 
-**Can I use ServiceBridge alongside existing infrastructure?**
-Yes. You can adopt incrementally — start with RPC between two services, add events later, then workflows. ServiceBridge doesn't require replacing your existing broker or mesh all at once.
+**How do I scale horizontally?** Run as many SDK instances as you like; the runtime load-balances RPC across live instances and fails over automatically. The runtime itself is a single source of truth backed by PostgreSQL.
 
-**What happens when the control plane is down?**
-In-flight direct RPC calls continue working (they go service-to-service, not through the control plane). New discovery lookups, event publishes, and telemetry writes are queued in the SDK offline queue and flushed when the control plane recovers.
+**What happens on a transient disconnect?** Published events sit in the local SQLite outbox and drain when the connection returns. The SDK auto-reconnects (configurable) and rotates certs with overlap so live instances don't drop traffic.
 
-**What databases does the runtime support?**
-PostgreSQL 16+. The runtime uses PostgreSQL for all persistence: traces, events, workflows, jobs, service registry, and configuration.
+**Where do I see traces, metrics and the DLQ?** In the runtime dashboard on `:14444`. Tracing, metrics and the dead-letter queue are operated there.
 
----
-
-## Community and Support
-
-- Website: [servicebridge.dev](https://servicebridge.dev)
-- GitHub: [github.com/service-bridge](https://github.com/service-bridge)
-- SDK monorepo: [README.md](../README.md)
+**Node or Bun?** Both. Node 18+ or any current Bun. Bun-native APIs are used where available.
 
 ---
 
-## License
+## Community
 
-Free for non-commercial use. Commercial use requires a separate license. See [LICENSE](../LICENSE).
+- **Website & docs:** [servicebridge.dev](https://servicebridge.dev) · [servicebridge.dev/docs](https://servicebridge.dev/docs)
+- **SDK umbrella repo (all languages):** [github.com/service-bridge/sdk](https://github.com/service-bridge/sdk)
+- **Runtime:** [github.com/servicebridge2/runtime](https://github.com/servicebridge2/runtime)
 
-Copyright (c) 2026 Eugene Surkov.
+This is an alpha release (`2.0.0-alpha`). The API is stabilising — issues and feedback are welcome.
 
 ---
 
-## Keywords
+## License
 
-service-bridge · servicebridge · npm install service-bridge · npm i service-bridge · bun add service-bridge · Node.js SDK · TypeScript SDK · JavaScript microservices · RPC · gRPC · event bus · event-driven · distributed tracing · workflow orchestration · background jobs · cron · mTLS · service mesh · service discovery · zero sidecar · Istio alternative · Envoy alternative · RabbitMQ alternative · Temporal alternative · Jaeger alternative · PostgreSQL · Docker · Kubernetes · DLQ · dead letter queue · saga · distributed transactions · AI agent orchestration · Express middleware · Fastify middleware · HTTP middleware · observability · Prometheus · tracing · service catalog · durable events · retries · idempotency · auto mTLS · runtime dashboard · production ready · microservice communication
+Licensed under the **MIT License** — see [LICENSE](./LICENSE). Free for any use, including commercial; you only need to keep the copyright and license notice (attribution to esurkov1 <esurkovv@yandex.ru>).