service-bridge 1.1.0-dev.27 → 1.1.1-dev.30

package/README.md

@@ -953,6 +953,198 @@ try {
 
 ---
 
+## 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',
+  serviceName: 'my-worker',
+  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',
+});
+
+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();
+
+// Пропуск — ускоряем пинги
+const missCount = hb.onMiss();
+if (missCount >= 2) {
+  // reconnect
+}
+```
+
+Алгоритм: базовый интервал `intervalMs / 3`; при пропусках делится на `2^miss` (min 2s); при стабильном RTT < 50ms удваивается (max 30s).
+
+### Кредитное управление потоком
+
+```typescript
+import { FlowControlStateV2 } from 'service-bridge';
+
+const fc = new FlowControlStateV2(64, 1, 128);
+
+if (fc.tryConsume()) {
+  // dispatch command
+}
+
+// Команда завершена — вернуть permit
+fc.release(1);
+
+// Сервер прислал FlowControlUpdate
+fc.setWindow(32);
+```
+
+### 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();
+
+while (true) {
+  if (backoff.isCircuitOpen()) break; // 10+ сбоев подряд
+
+  const delayMs = backoff.next();
+  await new Promise(r => setTimeout(r, delayMs));
+
+  try {
+    // reconnect...
+    backoff.reset();
+  } catch {
+    backoff.recordFail();
+  }
+}
+```
+
+### 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 |
+
+---
+
 ## FAQ
 
 **How does ServiceBridge handle service failures?**

package/dist/index.js

@@ -12,6 +12,312 @@ import * as protobuf from "protobufjs";
 // sdk/src/generated/servicebridge-package-definition.ts
 var DESCRIPTOR_SET_BASE64 = "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";
 
+// sdk/src/session_v2.ts
+class AdaptiveHeartbeatV2 {
+  intervalMs;
+  timeoutMs;
+  missCount = 0;
+  rttEwma = 0;
+  alpha = 0.3;
+  constructor(intervalMs, timeoutMs) {
+    this.intervalMs = intervalMs;
+    this.timeoutMs = timeoutMs;
+  }
+  nextIntervalMs() {
+    let base = this.intervalMs / 3;
+    if (this.missCount > 0) {
+      const shift = Math.min(this.missCount, 4);
+      base = base / 2 ** shift;
+    } else if (this.rttEwma > 0 && this.rttEwma < 50) {
+      base = Math.min(base * 2, 30000);
+    }
+    return Math.max(2000, Math.min(30000, base));
+  }
+  onPong(rttMs) {
+    this.rttEwma = this.alpha * rttMs + (1 - this.alpha) * this.rttEwma;
+    this.missCount = 0;
+  }
+  onMiss() {
+    return ++this.missCount;
+  }
+  resetMiss() {
+    this.missCount = 0;
+  }
+  getTimeoutMs() {
+    return this.timeoutMs;
+  }
+}
+
+class FlowControlStateV2 {
+  permits;
+  window;
+  minW;
+  maxW;
+  constructor(initial, min, max) {
+    this.permits = initial;
+    this.window = initial;
+    this.minW = min;
+    this.maxW = max;
+  }
+  tryConsume() {
+    if (this.permits <= 0)
+      return false;
+    this.permits--;
+    return true;
+  }
+  release(n) {
+    this.permits += n;
+  }
+  available() {
+    return this.permits;
+  }
+  setWindow(n) {
+    this.window = Math.max(this.minW, Math.min(this.maxW, n));
+    this.permits = this.window;
+  }
+  getWindow() {
+    return this.window;
+  }
+}
+
+class BackoffV2 {
+  attempt = 0;
+  baseMs = 100;
+  maxMs = 30000;
+  circuitFails = 0;
+  next() {
+    this.attempt++;
+    const calculated = this.baseMs * 2 ** Math.min(this.attempt, 10);
+    const capped = Math.min(calculated, this.maxMs);
+    const jittered = Math.random() * capped;
+    return Math.max(this.baseMs, jittered);
+  }
+  reset() {
+    this.attempt = 0;
+    this.circuitFails = 0;
+  }
+  recordFail() {
+    this.circuitFails++;
+  }
+  isCircuitOpen() {
+    return this.circuitFails >= 10;
+  }
+}
+
+class PositionTrackerV2 {
+  lastReceivedSeq = BigInt(0);
+  lastSentSeq = BigInt(0);
+  completedIds = new Set;
+  maxCompleted = 512;
+  recordReceived(seq) {
+    if (seq > this.lastReceivedSeq)
+      this.lastReceivedSeq = seq;
+  }
+  recordSent(seq) {
+    if (seq > this.lastSentSeq)
+      this.lastSentSeq = seq;
+  }
+  markCompleted(commandId) {
+    this.completedIds.add(commandId);
+    if (this.completedIds.size > this.maxCompleted) {
+      const first = this.completedIds.values().next().value;
+      if (first !== undefined)
+        this.completedIds.delete(first);
+    }
+  }
+  getResumeState(token, epoch) {
+    return {
+      resumeToken: token,
+      epoch,
+      lastReceivedSeq: this.lastReceivedSeq,
+      lastSentSeq: this.lastSentSeq,
+      completedCommandIds: Array.from(this.completedIds)
+    };
+  }
+}
+
+class ConfigPushStateV2 {
+  defaultMode = "direct";
+  serviceOverrides = {};
+  functionOverrides = {};
+  apply(config) {
+    if (config.defaultMode)
+      this.defaultMode = config.defaultMode;
+    if (config.serviceOverrides) {
+      Object.assign(this.serviceOverrides, config.serviceOverrides);
+    }
+    if (config.functionOverrides) {
+      Object.assign(this.functionOverrides, config.functionOverrides);
+    }
+  }
+  resolveMode(fnName) {
+    const fnOverride = this.functionOverrides[fnName];
+    if (fnOverride?.mode)
+      return fnOverride.mode;
+    const svcName = fnName.includes("/") ? fnName.split("/")[0] : fnName;
+    const svcOverride = this.serviceOverrides[svcName];
+    if (svcOverride?.mode)
+      return svcOverride.mode;
+    return this.defaultMode;
+  }
+}
+
+class V2SessionClient {
+  config;
+  _state = "connecting";
+  resumeToken = "";
+  epoch = BigInt(0);
+  position;
+  flowCtrl;
+  heartbeat;
+  backoff;
+  configPush;
+  _draining = false;
+  _stopped = false;
+  constructor(config) {
+    this.config = {
+      serverAddress: config.serverAddress,
+      serviceName: config.serviceName,
+      instanceId: config.instanceId,
+      zone: config.zone ?? "",
+      transportMode: config.transportMode ?? "direct",
+      maxInflight: config.maxInflight ?? 128,
+      minInflight: config.minInflight ?? 1,
+      sdkVersion: config.sdkVersion ?? "node-v2.0.0",
+      capabilities: config.capabilities ?? [],
+      tlsEnabled: config.tlsEnabled ?? false,
+      certPem: config.certPem ?? "",
+      keyPem: config.keyPem ?? "",
+      caPem: config.caPem ?? ""
+    };
+    this.position = new PositionTrackerV2;
+    this.flowCtrl = new FlowControlStateV2(this.config.maxInflight, this.config.minInflight, this.config.maxInflight);
+    this.heartbeat = new AdaptiveHeartbeatV2(1e4, 30000);
+    this.backoff = new BackoffV2;
+    this.configPush = new ConfigPushStateV2;
+  }
+  get state() {
+    return this._state;
+  }
+  get isDraining() {
+    return this._draining;
+  }
+  get isStopped() {
+    return this._stopped;
+  }
+  getHelloFields() {
+    const rs = this.position.getResumeState(this.resumeToken, this.epoch);
+    return {
+      identity: {
+        serviceName: this.config.serviceName,
+        instanceId: this.config.instanceId,
+        transport: this.config.transportMode
+      },
+      maxInflight: this.config.maxInflight,
+      minInflight: this.config.minInflight,
+      resumeToken: rs.resumeToken,
+      epoch: rs.epoch,
+      lastReceivedSeq: rs.lastReceivedSeq,
+      lastSentSeq: rs.lastSentSeq,
+      completedCommandIds: rs.completedCommandIds,
+      sdkVersion: this.config.sdkVersion,
+      capabilities: this.config.capabilities,
+      zone: this.config.zone,
+      transportMode: this.config.transportMode
+    };
+  }
+  onHelloAck(ack) {
+    this.resumeToken = ack.resumeToken;
+    this.epoch = ack.epoch;
+    this._state = "ready";
+    this.flowCtrl.setWindow(ack.initialPermits);
+    this.heartbeat = new AdaptiveHeartbeatV2(ack.heartbeatIntervalMs, ack.heartbeatTimeoutMs);
+    this.backoff.reset();
+    console.log(`[session-v2] hello_ack session=${ack.sessionId} resumed=${ack.resumed} epoch=${ack.epoch}`);
+  }
+  onCommandReceived(seq, commandId) {
+    this.position.recordReceived(seq);
+    if (!this.flowCtrl.tryConsume()) {
+      console.warn(`[session-v2] no permits for command ${commandId}, backpressure`);
+      return false;
+    }
+    if (this._state === "ready")
+      this._state = "active";
+    return true;
+  }
+  onCommandCompleted(seq, commandId) {
+    this.position.markCompleted(commandId);
+    this.position.recordSent(seq);
+    this.flowCtrl.release(1);
+  }
+  onPermitGrant(additional) {
+    this.flowCtrl.release(additional);
+  }
+  onFlowControlUpdate(newWindowSize, reason) {
+    this.flowCtrl.setWindow(newWindowSize);
+    console.log(`[session-v2] flow_control_update window=${newWindowSize} reason=${reason}`);
+  }
+  onPong(rttMs) {
+    this.heartbeat.onPong(rttMs);
+    if (this._state === "suspended") {
+      this._state = "ready";
+      console.log("[session-v2] heartbeat resumed, state→ready");
+    }
+  }
+  onHeartbeatMiss() {
+    const count = this.heartbeat.onMiss();
+    if (count >= 2 && (this._state === "ready" || this._state === "active")) {
+      this._state = "suspended";
+      console.warn(`[session-v2] heartbeat miss ${count}, state→suspended`);
+      return true;
+    }
+    return false;
+  }
+  onDrain(reason, deadlineMs) {
+    if (!this._draining) {
+      this._draining = true;
+      this._state = "draining";
+      console.log(`[session-v2] drain initiated reason=${reason} deadline=${deadlineMs}ms`);
+    }
+  }
+  onGoaway(code, reason) {
+    console.log(`[session-v2] goaway code=${code} reason=${reason}`);
+    switch (code) {
+      case "GOAWAY_FENCED":
+        this._state = "fenced";
+        this.stop();
+        break;
+      case "GOAWAY_GRACEFUL_SHUTDOWN":
+        this._state = "closed";
+        break;
+      default:
+        this._state = "closed";
+    }
+  }
+  onConfigPush(config) {
+    this.configPush.apply(config);
+    console.log("[session-v2] config push applied");
+  }
+  resolveTransportMode(fnName) {
+    return this.configPush.resolveMode(fnName);
+  }
+  stop() {
+    this._stopped = true;
+    this._state = "closed";
+  }
+}
+function validateV2Config(cfg) {
+  if (!cfg.serverAddress)
+    throw new Error("servicebridge: serverAddress is required");
+  if (!cfg.serviceName)
+    throw new Error("servicebridge: serviceName is required");
+  if (!cfg.instanceId)
+    throw new Error("servicebridge: instanceId is required");
+  if (cfg.transportMode && cfg.transportMode !== "direct" && cfg.transportMode !== "proxy") {
+    throw new Error(`servicebridge: transportMode must be 'direct' or 'proxy', got '${cfg.transportMode}'`);
+  }
+}
+
 // sdk/src/grpc-client.ts
 function outboundIP() {
   return new Promise((resolve) => {
@@ -591,13 +897,16 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
   const fnAliasMap = new Map;
   const functionChannels = new Map;
   let isOnline = false;
+  let isFlushing = false;
   let stopped = false;
-  let onlineRestoreTimer = null;
+  let isWatchingChannel = false;
   const offlineQueue = [];
   let workerServer = null;
   let workerSessionStream = null;
   let workerSessionReconnectTimer = null;
   let workerSessionPingTimer = null;
+  let workerSessionPositionTimer = null;
+  let v2Session = null;
   let serveState = null;
   let heartbeatTimer = null;
   let registrationSyncPromise = null;
@@ -656,7 +965,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         span_id: op.spanId,
         parent_span_id: op.parentSpanId,
         fn: op.fn,
-        started_at: String(op.startedAt),
+        started_at: op.startedAt,
         input: op.inputBuf,
         attempt: op.attempt
       }
@@ -670,7 +979,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         parent_span_id: op.parentSpanId,
         fn: op.fn,
         service_name: service,
-        started_at: String(op.startedAt),
+        started_at: op.startedAt,
         input: op.inputBuf,
         attempt: op.attempt,
         instance_id: serveState?.instanceId ?? ""
@@ -683,8 +992,8 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         trace_id: op.traceId,
         span_id: op.spanId,
         fn: op.fn,
-        started_at: String(op.startedAt),
-        duration_ms: String(op.durationMs),
+        started_at: op.startedAt,
+        duration_ms: op.durationMs,
         success: op.success,
         error: op.error ?? "",
         input: op.inputBuf,
@@ -700,8 +1009,8 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         span_id: op.spanId,
         fn: op.fn,
         service_name: service,
-        started_at: String(op.startedAt),
-        duration_ms: String(op.durationMs),
+        started_at: op.startedAt,
+        duration_ms: op.durationMs,
         success: op.success,
         error: op.error ?? "",
         input: op.inputBuf,
@@ -900,36 +1209,43 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     }
   }
   _controlReady.then(() => {
-    isOnline = true;
-    flushQueue().catch((err) => {
-      if (isConnectionError(err))
-        scheduleOnlineRestore();
-      else
-        reportSDKError("flush-on-ready", err);
-    });
+    watchChannelConnectivity();
   }).catch(() => {});
-  function scheduleOnlineRestore() {
-    if (stopped || isOnline || onlineRestoreTimer)
+  function watchChannelConnectivity() {
+    isWatchingChannel = false;
+    if (stopped)
       return;
-    onlineRestoreTimer = setTimeout(() => {
-      onlineRestoreTimer = null;
-      if (!stopped) {
+    const channel = stub.getChannel();
+    const state = channel.getConnectivityState(true);
+    if (state === grpc.connectivityState.READY) {
+      if (!isOnline) {
         isOnline = true;
         const queueLen = offlineQueue.length;
         console.info(`[servicebridge] reconnected to runtime${queueLen > 0 ? ` — flushing ${queueLen} queued operation(s)` : ""}`);
-        flushQueue().catch((err) => {
-          if (isConnectionError(err))
-            scheduleOnlineRestore();
-          else
-            reportSDKError("flush-on-restore", err);
+        flushQueue().then(() => {
+          if (isOnline)
+            scheduleNextHeartbeat(100);
+        }).catch((err) => {
+          reportSDKError("flush-on-restore", err);
         });
-        scheduleNextHeartbeat(100);
       }
-    }, 2000);
+    } else if (state === grpc.connectivityState.TRANSIENT_FAILURE) {
+      if (isOnline) {
+        isOnline = false;
+        console.warn("[servicebridge] lost connection to runtime — entering offline mode");
+      }
+    }
+    isWatchingChannel = true;
+    channel.watchConnectivityState(state, Infinity, watchChannelConnectivity);
+  }
+  function ensureChannelWatch() {
+    if (!isWatchingChannel && !stopped) {
+      watchChannelConnectivity();
+    }
   }
   function isConnectionError(e) {
     const code = e?.code;
-    return code === grpc.status.UNAVAILABLE || code === grpc.status.UNKNOWN || code === grpc.status.DEADLINE_EXCEEDED || code === grpc.status.RESOURCE_EXHAUSTED || code === grpc.status.INTERNAL;
+    return code === grpc.status.UNAVAILABLE || code === grpc.status.UNKNOWN;
   }
   function normalizeUnknownErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -962,7 +1278,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
           console.warn("[servicebridge] lost connection to runtime — entering offline mode");
         }
         isOnline = false;
-        scheduleOnlineRestore();
+        ensureChannelWatch();
         enqueueOffline({
           type: "reportCallStart",
           traceId,
@@ -1013,7 +1329,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
           console.warn("[servicebridge] lost connection to runtime — entering offline mode");
         }
         isOnline = false;
-        scheduleOnlineRestore();
+        ensureChannelWatch();
         enqueueOffline({
           type: "reportCall",
           traceId,
@@ -1033,66 +1349,71 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     });
   }
   async function flushQueue() {
-    if (offlineQueue.length === 0)
+    if (isFlushing || offlineQueue.length === 0)
       return;
+    isFlushing = true;
     const snapshot = offlineQueue.slice();
     let flushed = 0;
-    while (offlineQueue.length > 0 && isOnline) {
-      const op = offlineQueue[0];
-      try {
-        if (op.type === "event") {
-          await new Promise((res, rej) => {
-            stub.Publish({
-              topic: op.topic,
-              payload: toJsonBuffer(op.payload),
-              headers: toWireStringMap(op.opts?.headers),
-              trace_id: op.opts?.traceId ?? "",
-              parent_span_id: op.opts?.parentSpanId ?? "",
-              producer_service: service,
-              idempotency_key: op.opts?.idempotencyKey ?? ""
-            }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
-          });
-        } else if (op.type === "job") {
-          await new Promise((res, rej) => {
-            stub.RegisterJob({
-              cron_expr: op.opts.cron ?? "",
-              timezone: op.opts.timezone ?? "UTC",
-              misfire_policy: op.opts.misfire ?? "fire_now",
-              target_type: op.opts.via ?? "rpc",
-              target_ref: op.target,
-              delay_ms: op.opts.delay ?? 0,
-              service_name: service,
-              retry_policy_json: op.opts.retryPolicyJson ?? "{}"
-            }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
-          });
-        } else if (op.type === "workflow") {
-          await new Promise((res, rej) => {
-            stub.RegisterWorkflow({
-              name: op.name,
-              definition: JSON.stringify(op.steps),
-              opts: op.opts ? JSON.stringify(op.opts) : "{}",
-              service_name: service
-            }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
-          });
-        } else if (op.type === "reportCallStart") {
-          await sendReportCallStart({ ...op });
-        } else if (op.type === "reportCall") {
-          await sendReportCall(op);
-        }
-        offlineQueue.shift();
-        flushed++;
-      } catch (err) {
-        if (isConnectionError(err)) {
-          if (isOnline) {
-            console.warn("[servicebridge] lost connection to runtime — entering offline mode");
+    try {
+      while (offlineQueue.length > 0 && isOnline) {
+        const op = offlineQueue[0];
+        try {
+          if (op.type === "event") {
+            await new Promise((res, rej) => {
+              stub.Publish({
+                topic: op.topic,
+                payload: toJsonBuffer(op.payload),
+                headers: toWireStringMap(op.opts?.headers),
+                trace_id: op.opts?.traceId ?? "",
+                parent_span_id: op.opts?.parentSpanId ?? "",
+                producer_service: service,
+                idempotency_key: op.opts?.idempotencyKey ?? ""
+              }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
+            });
+          } else if (op.type === "job") {
+            await new Promise((res, rej) => {
+              stub.RegisterJob({
+                cron_expr: op.opts.cron ?? "",
+                timezone: op.opts.timezone ?? "UTC",
+                misfire_policy: op.opts.misfire ?? "fire_now",
+                target_type: op.opts.via ?? "rpc",
+                target_ref: op.target,
+                delay_ms: op.opts.delay ?? 0,
+                service_name: service,
+                retry_policy_json: op.opts.retryPolicyJson ?? "{}"
+              }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
+            });
+          } else if (op.type === "workflow") {
+            await new Promise((res, rej) => {
+              stub.RegisterWorkflow({
+                name: op.name,
+                definition: JSON.stringify(op.steps),
+                opts: op.opts ? JSON.stringify(op.opts) : "{}",
+                service_name: service
+              }, meta, unaryDeadlineOptions(), (err) => err ? rej(err) : res());
+            });
+          } else if (op.type === "reportCallStart") {
+            await sendReportCallStart({ ...op });
+          } else if (op.type === "reportCall") {
+            await sendReportCall(op);
+          }
+          offlineQueue.shift();
+          flushed++;
+        } catch (err) {
+          if (isConnectionError(err)) {
+            if (isOnline) {
+              console.warn("[servicebridge] lost connection to runtime — entering offline mode");
+            }
+            isOnline = false;
+            ensureChannelWatch();
+            break;
           }
-          isOnline = false;
-          scheduleOnlineRestore();
-          break;
+          reportSDKError("flush-offline-queue", err);
+          offlineQueue.shift();
         }
-        reportSDKError("flush-offline-queue", err);
-        break;
       }
+    } finally {
+      isFlushing = false;
     }
     if (flushed > 0) {
       const remaining = offlineQueue.length;
@@ -1174,7 +1495,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       });
     });
   }
-  async function syncRegistrations(reason) {
+  async function reconcileRegistrations(reason) {
     if (!serveState)
       return;
     if (registrationSyncPromise) {
@@ -1182,50 +1503,44 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     }
     const state = serveState;
     registrationSyncPromise = (async () => {
-      const nextGroups = new Set;
-      for (const [fn, fnEntry] of fnHandlers.entries()) {
-        await new Promise((resolve, reject) => {
-          stub.RegisterFunction({
-            fn_name: fn,
-            service_name: service,
-            instance_id: state.instanceId,
-            endpoint: state.endpoint,
-            transport: state.transport,
-            weight: Math.max(1, state.opts.weight ?? 1),
-            input_schema_json: fnEntry.opts.schema?.input ? JSON.stringify(fnEntry.opts.schema.input) : "",
-            output_schema_json: fnEntry.opts.schema?.output ? JSON.stringify(fnEntry.opts.schema.output) : ""
-          }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `register-function:${reason}:${fn}`)) : resolve());
-        });
-      }
-      for (const entry of eventHandlers.values()) {
-        const groupName = entry.groupName;
-        await new Promise((resolve, reject) => {
-          stub.RegisterConsumerGroup({
-            name: groupName,
-            pattern: entry.pattern,
-            mode: "shared",
-            retry_policy_json: entry.opts.retryPolicyJson ?? "{}",
-            active: true,
-            filter_expr: entry.opts.filterExpr ?? ""
-          }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `register-group:${reason}:${groupName}`)) : resolve());
-        });
-        await new Promise((resolve, reject) => {
-          stub.RegisterGroupMember({
-            group_name: groupName,
+      const functions = Array.from(fnHandlers.entries()).map(([fn, fnEntry]) => ({
+        fn_name: fn,
+        weight: Math.max(1, state.opts.weight ?? 1),
+        input_schema_json: fnEntry.opts.schema?.input ? JSON.stringify(fnEntry.opts.schema.input) : "",
+        output_schema_json: fnEntry.opts.schema?.output ? JSON.stringify(fnEntry.opts.schema.output) : "",
+        allowed_callers: fnEntry.opts.allowedCallers ?? []
+      }));
+      const consumerGroups = Array.from(eventHandlers.values()).map((entry) => ({
+        name: entry.groupName,
+        pattern: entry.pattern,
+        mode: "shared",
+        retry_policy_json: entry.opts.retryPolicyJson ?? "{}",
+        active: true,
+        filter_expr: entry.opts.filterExpr ?? ""
+      }));
+      const metrics = getProcessMetrics();
+      await new Promise((resolve, reject) => {
+        stub.Reconcile({
+          identity: {
             service_name: service,
             instance_id: state.instanceId,
             endpoint: state.endpoint,
-            transport: state.transport,
-            weight: Math.max(1, state.opts.weight ?? 1)
-          }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `register-member:${reason}:${groupName}`)) : resolve());
-        });
-        nextGroups.add(groupName);
-      }
+            transport: state.transport
+          },
+          functions,
+          consumer_groups: consumerGroups,
+          transport_mode: "TRANSPORT_MODE_DIRECT",
+          zone: "",
+          metrics: {
+            cpu_percent: metrics.cpuPercent ?? null,
+            ram_mb: metrics.ramMb ?? null
+          }
+        }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `reconcile:${reason}`)) : resolve());
+      });
       registeredGroups.clear();
-      for (const groupName of nextGroups) {
-        registeredGroups.add(groupName);
+      for (const entry of eventHandlers.values()) {
+        registeredGroups.add(entry.groupName);
       }
-      await sendHeartbeat();
     })().finally(() => {
       registrationSyncPromise = null;
     });
@@ -1256,9 +1571,9 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
           console.warn("[servicebridge] lost connection to runtime — entering offline mode");
         }
         isOnline = false;
-        scheduleOnlineRestore();
+        ensureChannelWatch();
       } else if (isRegistryResyncRequiredError(err)) {
-        await syncRegistrations("heartbeat-resync");
+        await reconcileRegistrations("heartbeat-resync");
       } else {
         reportSDKError("heartbeat", err);
       }
@@ -1424,6 +1739,10 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       clearInterval(workerSessionPingTimer);
       workerSessionPingTimer = null;
     }
+    if (workerSessionPositionTimer) {
+      clearInterval(workerSessionPositionTimer);
+      workerSessionPositionTimer = null;
+    }
     if (workerSessionReconnectTimer) {
       clearTimeout(workerSessionReconnectTimer);
       workerSessionReconnectTimer = null;
@@ -1492,6 +1811,10 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       result.error = normalizeUnknownErrorMessage(err);
     }
     stream.write({ command_result: result });
+    if (v2Session) {
+      v2Session.onCommandCompleted(BigInt(0), commandId);
+      stream.write({ permit_release: { released: 1 } });
+    }
   }
   function scheduleWorkerSessionReconnect(delayMs = 1000) {
     if (stopped || !serveState || workerSessionReconnectTimer)
@@ -1504,22 +1827,57 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       });
     }, delayMs);
   }
+  function adaptConfigPush(cp) {
+    const tc = cp?.transport_config;
+    if (!tc)
+      return {};
+    const defaultModeRaw = tc.default_mode;
+    return {
+      defaultMode: defaultModeRaw === "TRANSPORT_MODE_PROXY" ? "proxy" : "direct",
+      serviceOverrides: tc.service_overrides,
+      functionOverrides: tc.function_overrides
+    };
+  }
   async function openWorkerSession(initial) {
     if (!serveState) {
       throw new Error("serve() state is not initialized");
     }
     if (workerSessionStream)
       return;
+    if (!v2Session) {
+      v2Session = new V2SessionClient({
+        serverAddress: target,
+        serviceName: service,
+        instanceId: serveState.instanceId,
+        transportMode: "direct",
+        maxInflight: serveState.maxInFlight,
+        minInflight: 1
+      });
+    }
     const stream = stub.OpenWorkerSession(meta);
     workerSessionStream = stream;
-    const hello = {
+    const hf = v2Session.getHelloFields();
+    stream.write({
       hello: {
-        service_name: service,
-        instance_id: serveState.instanceId,
-        max_inflight: serveState.maxInFlight
+        identity: {
+          service_name: hf.identity.serviceName,
+          instance_id: hf.identity.instanceId,
+          endpoint: serveState.endpoint,
+          transport: serveState.transport
+        },
+        max_inflight: hf.maxInflight,
+        min_inflight: hf.minInflight,
+        resume_token: hf.resumeToken,
+        epoch: String(hf.epoch),
+        last_received_seq: String(hf.lastReceivedSeq),
+        last_sent_seq: String(hf.lastSentSeq),
+        completed_command_ids: hf.completedCommandIds,
+        sdk_version: hf.sdkVersion,
+        capabilities: hf.capabilities,
+        zone: hf.zone,
+        transport_mode: hf.transportMode === "proxy" ? "TRANSPORT_MODE_PROXY" : "TRANSPORT_MODE_DIRECT"
       }
-    };
-    stream.write(hello);
+    });
     workerSessionPingTimer = setInterval(() => {
       if (!workerSessionStream)
         return;
@@ -1527,7 +1885,50 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         ping: { timestamp_unix_ms: Date.now() }
       });
     }, 1e4);
+    workerSessionPositionTimer = setInterval(() => {
+      if (!workerSessionStream || !v2Session)
+        return;
+      workerSessionStream.write({
+        position_update: {
+          last_received_seq: String(v2Session.position.lastReceivedSeq)
+        }
+      });
+    }, 5000);
     stream.on("data", (msg) => {
+      if (msg.seq !== undefined && v2Session) {
+        v2Session.position.recordReceived(BigInt(msg.seq));
+      }
+      if (msg.hello_ack && v2Session) {
+        const ack = msg.hello_ack;
+        const helloAck = {
+          sessionId: ack.session_id ?? "",
+          resumeToken: ack.resume_token ?? "",
+          epoch: BigInt(ack.epoch ?? "0"),
+          resumed: ack.resumed ?? false,
+          resumeFromSeq: BigInt(ack.resume_from_seq ?? "0"),
+          replayedCommands: ack.replayed_commands ?? 0,
+          reconciledResults: ack.reconciled_results ?? 0,
+          heartbeatIntervalMs: ack.heartbeat_interval_ms ?? 1e4,
+          heartbeatTimeoutMs: ack.heartbeat_timeout_ms ?? 30000,
+          initialPermits: ack.initial_permits ?? 0,
+          maxPermits: ack.max_permits ?? 0,
+          effectiveTransportMode: ack.effective_transport_mode === "TRANSPORT_MODE_PROXY" ? "proxy" : "direct",
+          resumeFailReason: ack.resume_fail_reason
+        };
+        v2Session.onHelloAck(helloAck);
+      }
+      if (msg.goaway && v2Session) {
+        v2Session.onGoaway(msg.goaway.code ?? "", msg.goaway.reason ?? "");
+      }
+      if (msg.config_push && v2Session) {
+        v2Session.onConfigPush(adaptConfigPush(msg.config_push));
+      }
+      if (msg.permit_grant && v2Session) {
+        v2Session.onPermitGrant(msg.permit_grant.additional_permits ?? 0);
+      }
+      if (msg.flow_update && v2Session) {
+        v2Session.onFlowControlUpdate(msg.flow_update.new_window_size ?? 0, msg.flow_update.reason ?? "");
+      }
       if (msg.command) {
         processWorkerSessionCommand(msg.command).catch((err) => {
           reportSDKError("worker-session-command", err);
@@ -1541,6 +1942,10 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
         clearInterval(workerSessionPingTimer);
         workerSessionPingTimer = null;
       }
+      if (workerSessionPositionTimer) {
+        clearInterval(workerSessionPositionTimer);
+        workerSessionPositionTimer = null;
+      }
       workerSessionStream = null;
       if (err != null) {
         reportSDKError(operation, err);
@@ -1751,7 +2156,6 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
           }
           server.bindAsync(`${host}:0`, serverCreds, (err, p) => err ? reject(err) : resolve(p));
         });
-        workerServer.start();
         const endpoint = `${advertiseHost}:${port}`;
         const instanceId = opts.instanceId || Array.from(crypto.getRandomValues(new Uint8Array(3))).map((b) => b.toString(16).padStart(2, "0")).join("");
         serveState = {
@@ -1768,7 +2172,7 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
           serverName: tlsOpts?.serverName
         };
         await openWorkerSession(true);
-        await syncRegistrations("initial");
+        await reconcileRegistrations("initial");
         scheduleNextHeartbeat();
         await _controlReady;
       } catch (err) {
@@ -1787,11 +2191,9 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     stop() {
       stopped = true;
       isOnline = false;
-      if (onlineRestoreTimer)
-        clearTimeout(onlineRestoreTimer);
+      isWatchingChannel = false;
       if (heartbeatTimer)
         clearTimeout(heartbeatTimer);
-      onlineRestoreTimer = null;
       heartbeatTimer = null;
       registeredGroups.clear();
       closeWorkerSession();
@@ -2227,8 +2629,15 @@ function captureConsole(svc) {
   }
 }
 export {
+  validateV2Config,
   servicebridge,
   runWithTraceContext,
   getTraceContext,
-  ServiceBridgeError
+  V2SessionClient,
+  ServiceBridgeError,
+  PositionTrackerV2,
+  FlowControlStateV2,
+  ConfigPushStateV2,
+  BackoffV2,
+  AdaptiveHeartbeatV2
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "service-bridge",
-  "version": "1.1.0-dev.27",
+  "version": "1.1.1-dev.30",
   "type": "module",
   "description": "ServiceBridge SDK for Node.js — production-ready RPC, durable events, workflows, jobs, and distributed tracing. One Go runtime + PostgreSQL replaces Istio, RabbitMQ, Temporal, and Jaeger.",
   "keywords": [