@inline-chat/hermes-agent-adapter 0.0.15 → 0.0.17

package/plugin/inline/sidecar/index.mjs

@@ -5568,7 +5568,449 @@ var require_websocket_server = __commonJS((exports, module) => {
 
 // src/sidecar/index.ts
 import http from "node:http";
-import { once } from "node:events";
+
+// src/sidecar/inbound-stream.ts
+class InboundStream {
+  consumer = null;
+  stopped = false;
+  changed = new Set;
+  attach(consumer) {
+    if (this.stopped) {
+      consumer.end();
+      return;
+    }
+    const previous = this.consumer;
+    this.consumer = consumer;
+    const retired = () => {
+      if (this.consumer === consumer) {
+        this.consumer = null;
+        this.wake();
+      }
+    };
+    consumer.once("close", retired);
+    consumer.on("error", retired);
+    this.wake();
+    previous?.end();
+  }
+  close() {
+    this.stopped = true;
+    const previous = this.consumer;
+    this.consumer = null;
+    this.wake();
+    previous?.end();
+  }
+  async deliver(event) {
+    const line = JSON.stringify(event) + `
+`;
+    while (!this.stopped) {
+      const owner = this.consumer;
+      if (!owner) {
+        await new Promise((resolve) => this.changed.add(resolve));
+        continue;
+      }
+      let cleanup = () => {};
+      const drained = new Promise((resolve) => {
+        const finish = (ok) => {
+          cleanup();
+          resolve(ok);
+        };
+        const onDrain = () => finish(true);
+        const onChange = () => finish(false);
+        cleanup = () => {
+          owner.off("drain", onDrain);
+          owner.off("close", onChange);
+          owner.off("error", onChange);
+          this.changed.delete(onChange);
+        };
+        owner.once("drain", onDrain);
+        owner.once("close", onChange);
+        owner.once("error", onChange);
+        this.changed.add(onChange);
+      });
+      try {
+        if (owner.destroyed || owner.writableEnded) {
+          if (this.consumer === owner)
+            this.consumer = null;
+          continue;
+        }
+        const accepted = owner.write(line);
+        if (this.consumer !== owner || this.stopped)
+          continue;
+        if (accepted)
+          return;
+        if (await drained && this.consumer === owner && !this.stopped)
+          return;
+      } catch {
+        if (this.consumer === owner)
+          this.consumer = null;
+      } finally {
+        cleanup();
+      }
+    }
+    throw new Error("Inbound stream closed before delivery completed");
+  }
+  wake() {
+    for (const resolve of this.changed)
+      resolve();
+    this.changed.clear();
+  }
+}
+
+// src/sidecar/inbound-delivery.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/sidecar/contract.ts
+var MAX_INLINE_ID = 9223372036854775807n;
+var MAX_UINT64 = 18446744073709551615n;
+var sensitiveUrlParams = new Set([
+  "access_token",
+  "auth",
+  "authorization",
+  "key",
+  "token"
+]);
+var botSettingsEventKinds = new Set([
+  "bot.chatSettings.request",
+  "bot.chatSettings.item.invoke"
+]);
+function inboundEventNeedsSenderResolution(event) {
+  return !botSettingsEventKinds.has(event.kind ?? "");
+}
+
+class SidecarError extends Error {
+  errorKind;
+  constructor(message, errorKind) {
+    super(message);
+    this.errorKind = errorKind;
+  }
+}
+function parseTarget(record) {
+  const targetRecord = asOptionalRecord(record.target) ?? record;
+  const chatId = readOptionalInlineId(targetRecord, "chatId");
+  const userId = readOptionalInlineId(targetRecord, "userId");
+  if (chatId && userId)
+    throw new SidecarError("target cannot include both chatId and userId", "bad_format");
+  if (chatId)
+    return { chatId };
+  if (userId)
+    return { userId };
+  throw new SidecarError("target requires chatId or userId", "bad_format");
+}
+function normalizeUploadKind(raw, filePath) {
+  if (raw === "photo" || raw === "image")
+    return "photo";
+  if (raw === "video")
+    return "video";
+  if (raw === "voice")
+    return "voice";
+  if (raw === "document" || raw === "file")
+    return "document";
+  const lower = filePath.toLowerCase();
+  if (/\.(png|jpg|jpeg|gif|webp|heic|heif)$/.test(lower))
+    return "photo";
+  if (/\.(mp4|mov|webm)$/.test(lower))
+    return "video";
+  return "document";
+}
+function normalizeError(error, redact = defaultErrorText) {
+  if (error instanceof SidecarError) {
+    return {
+      status: statusForErrorKind(error.errorKind),
+      errorKind: error.errorKind,
+      message: redact(error)
+    };
+  }
+  const message = redact(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("rate") && lower.includes("limit")) {
+    return { status: 429, errorKind: "rate_limited", message };
+  }
+  if (lower.includes("forbidden") || lower.includes("unauthorized")) {
+    return { status: 403, errorKind: "forbidden", message };
+  }
+  if (lower.includes("not found") || lower.includes("missing")) {
+    return { status: 404, errorKind: "not_found", message };
+  }
+  if (lower.includes("timeout") || lower.includes("network") || lower.includes("closed")) {
+    return { status: 503, errorKind: "transient", message };
+  }
+  return { status: 500, errorKind: "unknown", message };
+}
+function statusForErrorKind(errorKind) {
+  switch (errorKind) {
+    case "bad_format":
+      return 400;
+    case "forbidden":
+      return 403;
+    case "not_found":
+      return 404;
+    case "too_long":
+      return 413;
+    case "rate_limited":
+      return 429;
+    case "transient":
+      return 503;
+    case "unknown":
+      return 500;
+  }
+}
+function normalizeInboundEvent(event, meId, sender, meUsername) {
+  if (event.kind === "message.new" || event.kind === "message.edit") {
+    const message = asOptionalRecord(event.message);
+    return safeJson({
+      kind: event.kind,
+      chatId: event.chatId,
+      seq: event.seq,
+      date: event.date,
+      meId,
+      meUsername,
+      ...sender ? { sender } : {},
+      message: message ? normalizeMessage(message) : null
+    });
+  }
+  if (event.kind === "message.action.invoke") {
+    return safeJson({
+      ...event,
+      meId,
+      meUsername,
+      ...sender ? { sender } : {},
+      dataBase64: event.data instanceof Uint8Array ? Buffer.from(event.data).toString("base64") : typeof event.data === "string" ? event.data : ""
+    });
+  }
+  return safeJson({ ...event, meId, meUsername, ...sender ? { sender } : {} });
+}
+function normalizeMessage(message) {
+  return {
+    id: message.id,
+    fromId: message.fromId,
+    chatId: message.chatId,
+    peerId: message.peerId,
+    message: message.message ?? null,
+    out: Boolean(message.out),
+    date: message.date,
+    mentioned: Boolean(message.mentioned),
+    replyToMsgId: message.replyToMsgId ?? null,
+    entities: message.entities ?? null,
+    media: message.media ?? null,
+    attachments: message.attachments ?? null,
+    reactions: message.reactions ?? null,
+    replies: message.replies ?? null,
+    actions: message.actions ?? null,
+    rev: message.rev ?? null,
+    raw: message
+  };
+}
+function redactText(value, secrets) {
+  let text = value instanceof Error ? value.message : String(value);
+  for (const secret of secrets) {
+    const raw = typeof secret.value === "string" ? secret.value : "";
+    if (!raw)
+      continue;
+    text = text.split(raw).join(secret.label);
+  }
+  return text;
+}
+function redactUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return value;
+  }
+  if (url.username)
+    url.username = "redacted";
+  if (url.password)
+    url.password = "redacted";
+  const keys = Array.from(url.searchParams.keys());
+  for (const key of keys) {
+    const normalized = key.toLowerCase();
+    if (sensitiveUrlParams.has(normalized) || normalized.includes("token")) {
+      url.searchParams.set(key, "redacted");
+    }
+  }
+  return url.toString();
+}
+function safeJson(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value instanceof Uint8Array)
+    return Buffer.from(value).toString("base64");
+  if (Array.isArray(value))
+    return value.map(safeJson);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== undefined)
+        out[key] = safeJson(item);
+    }
+    return out;
+  }
+  return String(value);
+}
+function asRecord(value) {
+  const record = asOptionalRecord(value);
+  if (!record)
+    throw new SidecarError("expected JSON object", "bad_format");
+  return record;
+}
+function asOptionalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  return value;
+}
+function readRequiredString(record, key) {
+  const value = readOptionalString(record, key);
+  if (!value)
+    throw new SidecarError(`missing ${key}`, "bad_format");
+  return value;
+}
+function readOptionalString(record, key) {
+  const value = record[key];
+  if (typeof value === "string")
+    return value.trim() || undefined;
+  if (typeof value === "bigint" || typeof value === "number")
+    return String(value);
+  return;
+}
+function readOptionalBoolean(record, key) {
+  const value = record[key];
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    if (/^(1|true|yes|on)$/i.test(value))
+      return true;
+    if (/^(0|false|no|off)$/i.test(value))
+      return false;
+  }
+  return;
+}
+function readOptionalNumber(record, key) {
+  const value = record[key];
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return;
+}
+function readRequiredInlineId(record, key) {
+  const value = readOptionalInlineId(record, key);
+  if (value == null)
+    throw new SidecarError(`missing ${key}`, "bad_format");
+  return value;
+}
+function readOptionalInlineId(record, key) {
+  const value = record[key];
+  if (value == null || value === "")
+    return;
+  return parseInlineId(value, key);
+}
+function readInlineIdArray(record, key, maxItems, required = false) {
+  const value = record[key];
+  if (value == null) {
+    if (required)
+      throw new SidecarError(`missing ${key}`, "bad_format");
+    return [];
+  }
+  if (!Array.isArray(value))
+    throw new SidecarError(`${key} must be an array`, "bad_format");
+  if (value.length === 0 && required)
+    throw new SidecarError(`${key} must not be empty`, "bad_format");
+  if (value.length > maxItems)
+    throw new SidecarError(`${key} supports at most ${maxItems} items`, "bad_format");
+  const ids = [];
+  const seen = new Set;
+  for (let index = 0;index < value.length; index += 1) {
+    const id = parseInlineId(value[index], `${key}[${index}]`);
+    const normalized = id.toString();
+    if (seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    ids.push(id);
+  }
+  return ids;
+}
+function parseOptionalInt(value) {
+  const raw = (value || "").trim();
+  if (!raw || !/^\d+$/.test(raw))
+    return;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function parseInlineId(value, field) {
+  try {
+    if (typeof value === "number" && (!Number.isSafeInteger(value) || value <= 0)) {
+      throw new Error("unsafe number");
+    }
+    const raw = typeof value === "string" ? value.trim() : value;
+    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
+      throw new Error("invalid digits");
+    if (typeof raw !== "string" && typeof raw !== "bigint" && typeof raw !== "number") {
+      throw new Error("invalid type");
+    }
+    const parsed = BigInt(raw);
+    if (parsed <= 0n || parsed > MAX_INLINE_ID)
+      throw new Error("out of range");
+    return parsed;
+  } catch {
+    throw new SidecarError(`${field} must be a positive signed 64-bit integer`, "bad_format");
+  }
+}
+function parseUnsigned64Id(value, field) {
+  try {
+    if (typeof value === "number" && (!Number.isSafeInteger(value) || value <= 0)) {
+      throw new Error("unsafe number");
+    }
+    const raw = typeof value === "string" ? value.trim() : value;
+    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
+      throw new Error("invalid digits");
+    if (typeof raw !== "string" && typeof raw !== "bigint" && typeof raw !== "number") {
+      throw new Error("invalid type");
+    }
+    const parsed = BigInt(raw);
+    if (parsed <= 0n || parsed > MAX_UINT64)
+      throw new Error("out of range");
+    return parsed;
+  } catch {
+    throw new SidecarError(`${field} must be a positive unsigned 64-bit integer`, "bad_format");
+  }
+}
+function defaultErrorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/sidecar/inbound-delivery.ts
+function explicitlyMentionsSelf(event, meId) {
+  if (!meId || event.kind !== "message.new" && event.kind !== "message.edit")
+    return false;
+  const message = event.message;
+  return message?.entities?.entities?.some((e) => e.entity?.oneofKind === "mention" && e.entity.mention?.userId?.toString() === meId) ?? false;
+}
+async function deliverInboundEvent(event, owner) {
+  const explicitMention = explicitlyMentionsSelf(event, owner.meId);
+  while (!owner.signal.aborted) {
+    const resolution = explicitMention ? { provenanceVerified: false } : inboundEventNeedsSenderResolution(event) ? await owner.resolveSender(event) : { provenanceVerified: true };
+    owner.signal.throwIfAborted();
+    if (!explicitMention && !resolution.provenanceVerified && (event.kind === "message.new" || event.kind === "message.edit")) {
+      await delay(1000, undefined, { signal: owner.signal });
+      continue;
+    }
+    const normalized = normalizeInboundEvent(event, owner.meId, resolution.profile, owner.meUsername);
+    await owner.deliver(resolution.provenanceVerified ? normalized : { ...normalized, _inlineSenderProvenanceVerified: false });
+    return;
+  }
+  owner.signal.throwIfAborted();
+}
+
+// src/sidecar/index.ts
 import { timingSafeEqual } from "node:crypto";
 import { mkdir, readFile as readFile3, stat } from "node:fs/promises";
 import path from "node:path";
@@ -38683,7 +39125,7 @@ var reportProgress = (job) => {
     job.input.onProgress?.({ acceptedBytes: acceptedBytes(job), totalBytes: job.input.source.byteCount });
   } catch {}
 };
-var delay = async (seconds, signal) => {
+var delay2 = async (seconds, signal) => {
   if (signal?.aborted)
     throw new NativeUploadError("canceled", "Upload was canceled");
   await new Promise((resolve, reject) => {
@@ -38966,7 +39408,7 @@ class NativeUploadClient {
     }
   }
   #resumeFinishAfter(job, seconds) {
-    delay(seconds, job.input.signal).then(() => {
+    delay2(seconds, job.input.signal).then(() => {
       if (job.settled)
         return;
       job.active = 0;
@@ -39074,6 +39516,13 @@ var asInlineId = (value, fieldName = "id") => {
 };
 
 // node_modules/@inline-chat/realtime-sdk/dist/utils/async-channel.js
+class ChannelConsumerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChannelConsumerError";
+  }
+}
+
 class AsyncChannelOverflowError extends Error {
   capacity;
   constructor(capacity) {
@@ -39183,6 +39632,7 @@ class AcknowledgedAsyncChannel {
   closed = false;
   failure = null;
   iteratorClaimed = false;
+  consumption = null;
   constructor(capacity, byteLimit) {
     this.capacity = capacity;
     this.byteLimit = byteLimit;
@@ -39196,7 +39646,7 @@ class AcknowledgedAsyncChannel {
   send(value) {
     if (this.closed)
       return Promise.resolve(false);
-    if (!this.waiter && this.queue.length >= this.capacity) {
+    if (!this.waiter && this.queue.length + (this.consumption?.active.size ?? 0) >= this.capacity) {
       throw new AsyncChannelOverflowError(this.capacity);
     }
     const bytes = this.byteLimit?.byteLength(value) ?? 0;
@@ -39216,6 +39666,7 @@ class AcknowledgedAsyncChannel {
         waiter.resolve({ value, done: false });
       } else {
         this.queue.push(item);
+        this.pumpConsumption();
       }
     });
   }
@@ -39230,6 +39681,16 @@ class AcknowledgedAsyncChannel {
       return;
     this.closed = true;
     this.failure = error;
+    const consumption = this.consumption;
+    this.consumption = null;
+    if (consumption) {
+      for (const item of consumption.active.keys())
+        item.acknowledge(false);
+      if (error)
+        consumption.reject(error);
+      else
+        consumption.resolve();
+    }
     this.active?.acknowledge(false);
     this.active = null;
     for (const item of this.queue)
@@ -39245,6 +39706,65 @@ class AcknowledgedAsyncChannel {
     else
       waiter.resolve({ value: undefined, done: true });
   }
+  consume(handler, key, concurrency = 8) {
+    if (this.iteratorClaimed)
+      return Promise.reject(new ChannelConsumerError("AcknowledgedAsyncChannel supports one consumer"));
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
+      return Promise.reject(new ChannelConsumerError("Consumer concurrency must be a positive safe integer"));
+    }
+    if (this.closed)
+      return this.failure ? Promise.reject(this.failure) : Promise.resolve();
+    this.iteratorClaimed = true;
+    return new Promise((resolve, reject) => {
+      this.consumption = { handler, key, concurrency, active: new Map, resolve, reject };
+      this.pumpConsumption();
+    });
+  }
+  pumpConsumption() {
+    const owner = this.consumption;
+    if (!owner || this.closed)
+      return;
+    try {
+      while (owner.active.size < owner.concurrency && this.queue.length > 0) {
+        if ([...owner.active.values()].includes(null))
+          return;
+        const keys = new Set(owner.active.values());
+        let index = -1;
+        let key = null;
+        for (let i = 0;i < this.queue.length; i++) {
+          const candidate = this.queue[i];
+          const candidateKey = owner.key(candidate.value);
+          if (candidateKey === null) {
+            if (i === 0 && owner.active.size === 0)
+              index = i;
+            break;
+          }
+          if (!keys.has(candidateKey)) {
+            index = i;
+            key = candidateKey;
+            break;
+          }
+        }
+        if (index < 0)
+          return;
+        const item = this.queue.splice(index, 1)[0];
+        owner.active.set(item, key);
+        Promise.resolve().then(() => owner.handler(item.value)).then(() => {
+          if (this.consumption !== owner)
+            return;
+          owner.active.delete(item);
+          this.bufferedBytes -= item.bytes;
+          item.acknowledge(true);
+          this.pumpConsumption();
+        }, (error) => {
+          if (this.consumption === owner)
+            this.fail(error instanceof Error ? error : new Error("Inbound handler failed"));
+        });
+      }
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error("Inbound routing failed"));
+    }
+  }
   [Symbol.asyncIterator]() {
     if (this.iteratorClaimed) {
       return {
@@ -39252,8 +39772,11 @@ class AcknowledgedAsyncChannel {
       };
     }
     this.iteratorClaimed = true;
+    let returned = false;
     return {
       next: () => {
+        if (returned)
+          return Promise.resolve({ value: undefined, done: true });
         if (this.active) {
           this.bufferedBytes -= this.active.bytes;
           this.active.acknowledge(true);
@@ -39277,6 +39800,11 @@ class AcknowledgedAsyncChannel {
         });
       },
       return: () => {
+        if (returned)
+          return Promise.resolve({ value: undefined, done: true });
+        returned = true;
+        this.waiter?.resolve({ value: undefined, done: true });
+        this.waiter = null;
         if (this.active) {
           this.bufferedBytes -= this.active.bytes;
           this.active.acknowledge(false);
@@ -39955,10 +40483,12 @@ var normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
 
 class ProtocolClientError extends Error {
   code;
+  rpcCode;
   constructor(code, details) {
     super(details?.message ?? code);
     this.code = code;
     this.name = `ProtocolClientError:${code}`;
+    this.rpcCode = details?.code;
   }
 }
 var commitOutcomeUnknownError = (message) => new ProtocolClientError("commit-outcome-unknown", { message });
@@ -43583,15 +44113,15 @@ class InlineProtocolV3Connection {
     if (!authorization?.temporary || authorization.expiresAt === undefined || this.#closing)
       return;
     const boundary = authorization.expiresAt * 1000 - TEMPORARY_KEY_ROTATION_MILLISECONDS;
-    const delay2 = boundary - this.#clock.nowMilliseconds();
-    if (!Number.isFinite(delay2) || delay2 <= 0) {
+    const delay3 = boundary - this.#clock.nowMilliseconds();
+    if (!Number.isFinite(delay3) || delay3 <= 0) {
       this.#markRotationDue();
       return;
     }
     const timer = setTimeout(() => {
       this.#rotationTimer = undefined;
       this.#scheduleRotationTimer();
-    }, Math.min(delay2, 2147000000));
+    }, Math.min(delay3, 2147000000));
     if (typeof timer !== "number" && typeof timer.unref === "function")
       timer.unref();
     this.#rotationTimer = timer;
@@ -44781,8 +45311,11 @@ class InlineSdkClient {
   peerResolutionRequestedByChatId = new Map;
   recoveryReconnectInFlight = null;
   degradedUpdateBuckets = new Map;
+  discoveryRetry = null;
+  recoveryRetries = new Map;
   liveCursorFences = new Set;
   liveAdmittedSeqByBucket = new Map;
+  liveDeliveriesByBucket = new Map;
   discoveryRound = null;
   discoveryInFlight = null;
   discoveryCommitInFlight = null;
@@ -44875,12 +45408,14 @@ class InlineSdkClient {
     }
   }
   async close() {
-    if (!this.started)
-      return;
+    const wasStarted = this.started;
     this.closed = true;
     this.started = false;
+    this.cancelRecoveryRetries();
     this.rejectOpen(new Error("closed"));
     this.eventStream.close();
+    if (!wasStarted)
+      return;
     await settleWithin(this.protocol.stopTransport(), closeJoinTimeoutMs, () => this.log.warn?.("Timed out stopping SDK transport during close"));
     await settleWithin(Promise.allSettled([
       ...this.catchUpInFlightByChatId.values(),
@@ -44942,6 +45477,20 @@ class InlineSdkClient {
   events() {
     return this.eventStream;
   }
+  consumeEvents(handler, options) {
+    return this.eventStream.consume(handler, (event) => {
+      const bucket = this.bucketForEvent(event);
+      if (bucket?.kind === "user")
+        return null;
+      if (bucket)
+        return this.updateBucketKey(bucket);
+      return "chatId" in event && typeof event.chatId === "bigint" ? `chat:${event.chatId}` : null;
+    }, options?.concurrency).catch(async (error) => {
+      if (!(error instanceof ChannelConsumerError))
+        await this.close();
+      throw error;
+    });
+  }
   exportState() {
     return {
       version: 1,
@@ -45351,6 +45900,7 @@ class InlineSdkClient {
       this.log.error?.("SDK listener crashed", failure);
       this.started = false;
       this.closed = true;
+      this.cancelRecoveryRetries();
       this.rejectOpen(failure);
       this.eventStream.fail(failure);
       this.protocol.stopTransport().catch((stopError) => {
@@ -45363,6 +45913,7 @@ class InlineSdkClient {
       return;
     this.authenticationError = error;
     this.started = false;
+    this.cancelRecoveryRetries();
     this.rejectOpen(error);
     this.eventStream.close();
     try {
@@ -45372,6 +45923,7 @@ class InlineSdkClient {
     }
   }
   async onOpen() {
+    this.cancelRecoveryRetries();
     this.requestCatchUpUser();
     for (const bucket of this.degradedUpdateBuckets.values()) {
       this.requestCatchUpForDegradedBucket(bucket);
@@ -45422,6 +45974,8 @@ class InlineSdkClient {
       return this.discoveryInFlight;
     if (this.discoveryCommitInFlight)
       return this.discoveryCommitInFlight;
+    if (this.discoveryRetry?.timer)
+      return;
     const round = {
       resultReceived: false,
       collectingHints: true,
@@ -45454,6 +46008,11 @@ class InlineSdkClient {
       this.log.warn?.("GET_UPDATES_STATE failed (continuing without date cursor)", error);
       if (this.discoveryRound === round)
         this.discoveryRound = null;
+      if (error instanceof ProtocolClientError && (error.code === "timeout" || error.code === "not-connected" || error.code === "capacity-exceeded" || error.rpcCode === RpcError_Code.INTERNAL_ERROR || error.rpcCode === 500 || error.rpcCode === RpcError_Code.RATE_LIMIT || error.rpcCode === 429)) {
+        this.scheduleDiscoveryRetry(error.rpcCode === RpcError_Code.RATE_LIMIT || error.rpcCode === 429 ? "rate_limited" : "discovery_failed");
+      } else {
+        this.log.error?.("Sync discovery unavailable", { reason: "request_rejected" });
+      }
     }
   }
   tryCommitDiscoveryRound(round) {
@@ -45478,12 +46037,15 @@ class InlineSdkClient {
         return;
       if (saved) {
         this.discoveryRound = null;
+        clearTimeout(this.discoveryRetry?.timer);
+        this.discoveryRetry = null;
         return;
       }
       this.state.dateCursor = previousDateCursor;
       this.scheduleStateSave();
       this.discoveryRound = null;
       this.log.warn?.("Failed to persist discovery checkpoint; preserving previous date cursor");
+      this.scheduleDiscoveryRetry("checkpoint_write_failed");
     }).finally(() => {
       if (this.discoveryCommitInFlight === commit)
         this.discoveryCommitInFlight = null;
@@ -45818,20 +46380,23 @@ class InlineSdkClient {
     try {
       acknowledged = this.eventStream.send(event);
     } catch (error) {
-      const bucket = this.bucketForEvent(event);
-      if (bucket) {
-        this.fenceLiveCursor(bucket);
-        this.markUpdateBucketDegraded(bucket);
-        this.requestCatchUpAfterEventOverflow(bucket, event);
+      const bucket2 = this.bucketForEvent(event);
+      if (bucket2) {
+        this.fenceLiveCursor(bucket2);
+        this.markUpdateBucketDegraded(bucket2);
+        this.requestCatchUpAfterEventOverflow(bucket2, event);
       }
       this.log.warn?.("Inbound event buffer overflow; durable cursor remains unchanged and transport will recover", {
-        bucket: bucket ? this.updateBucketKey(bucket) : "none",
+        bucket: bucket2 ? this.updateBucketKey(bucket2) : "none",
         error: extractErrorMessage(error)
       });
       this.requestRecoveryReconnect("inbound-event-buffer-overflow");
       return Promise.resolve(false);
     }
-    return acknowledged.then((applied) => {
+    const bucket = source === "live" ? this.sequencedBucketForEvent(event) : undefined;
+    const key = bucket ? this.updateBucketKey(bucket) : undefined;
+    const deliveries = key ? this.liveDeliveriesByBucket.get(key) ?? new Set : undefined;
+    const delivery = acknowledged.then((applied) => {
       if (applied) {
         onApplied?.();
         if (source === "live")
@@ -45839,8 +46404,16 @@ class InlineSdkClient {
       } else if (source === "live" && this.started) {
         this.recoverLiveEvent(event, "consumer-did-not-apply");
       }
+      deliveries?.delete(delivery);
+      if (key && deliveries?.size === 0)
+        this.liveDeliveriesByBucket.delete(key);
       return applied;
     });
+    if (key && deliveries) {
+      deliveries.add(delivery);
+      this.liveDeliveriesByBucket.set(key, deliveries);
+    }
+    return delivery;
   }
   bucketForEvent(event) {
     switch (event.kind) {
@@ -46018,20 +46591,25 @@ class InlineSdkClient {
   }
   requestCatchUpForDegradedBucket(bucket) {
     switch (bucket.kind) {
-      case "chat":
-        if (bucket.peer && this.isReliableChatPeer(bucket.peer)) {
-          this.requestCatchUpChat({ chatId: bucket.chatId, peer: bucket.peer });
+      case "chat": {
+        const request = this.catchUpRequestedByChatId.get(bucket.chatId) ?? this.peerResolutionRequestedByChatId.get(bucket.chatId);
+        const updateSeq = request && !request.toLatest ? request.endSeq : undefined;
+        const peer = bucket.peer ?? this.persistedChatPeer(bucket.chatId);
+        if (peer && this.isReliableChatPeer(peer)) {
+          this.requestCatchUpChat({ chatId: bucket.chatId, peer, updateSeq });
         } else {
-          const persistedPeer = this.persistedChatPeer(bucket.chatId);
-          if (persistedPeer)
-            this.requestCatchUpChat({ chatId: bucket.chatId, peer: persistedPeer });
-          else
-            this.resolvePersistedChatPeer(bucket.chatId);
+          this.resolvePersistedChatPeer(bucket.chatId, updateSeq);
         }
         return;
-      case "space":
-        this.requestCatchUpSpace({ spaceId: bucket.spaceId });
+      }
+      case "space": {
+        const request = this.catchUpRequestedBySpaceId.get(bucket.spaceId);
+        this.requestCatchUpSpace({
+          spaceId: bucket.spaceId,
+          updateSeq: request && !request.toLatest ? request.endSeq : undefined
+        });
         return;
+      }
       case "user":
         this.requestCatchUpUser(true);
         return;
@@ -46216,7 +46794,7 @@ class InlineSdkClient {
   bumpChatSeq(chatId, seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has(`chat:${chatId}`))
+    if (source === "live" && this.liveCursorFences.has(`chat:${chatId}`) && seq !== (this.state.lastSeqByChatId?.[chatId.toString()] ?? 0) + 1)
       return;
     if (!Number.isFinite(seq))
       return;
@@ -46225,6 +46803,7 @@ class InlineSdkClient {
     const key = chatId.toString();
     const prev = this.state.lastSeqByChatId[key] ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "chat", chatId });
       this.state.lastSeqByChatId[key] = seq;
       this.scheduleStateSave();
     }
@@ -46233,7 +46812,7 @@ class InlineSdkClient {
   bumpSpaceSeq(spaceId, seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has(`space:${spaceId}`))
+    if (source === "live" && this.liveCursorFences.has(`space:${spaceId}`) && seq !== (this.state.lastSeqBySpaceId?.[spaceId.toString()] ?? 0) + 1)
       return;
     if (!Number.isFinite(seq))
       return;
@@ -46242,6 +46821,7 @@ class InlineSdkClient {
     const key = spaceId.toString();
     const prev = this.state.lastSeqBySpaceId[key] ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "space", spaceId });
       this.state.lastSeqBySpaceId[key] = seq;
       this.scheduleStateSave();
     }
@@ -46256,12 +46836,13 @@ class InlineSdkClient {
   bumpUserSeq(seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has("user"))
+    if (source === "live" && this.liveCursorFences.has("user") && seq !== (this.state.lastUserSeq ?? 0) + 1)
       return;
     if (!Number.isFinite(seq) || seq <= 0)
       return;
     const prev = this.state.lastUserSeq ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "user" });
       this.state.lastUserSeq = seq;
       this.scheduleStateSave();
     }
@@ -46275,14 +46856,17 @@ class InlineSdkClient {
     if (this.userCatchUpInFlight) {
       return this.userCatchUpInFlight;
     }
+    if (this.recoveryRetries.get("user")?.timer)
+      return null;
     this.fenceLiveCursor({ kind: "user" });
     this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq ?? 0).catch((error) => {
-      this.markUpdateBucketDegraded({ kind: "user" });
+      this.recordCatchUpFailure({ kind: "user" }, error);
       this.log.warn?.("GET_UPDATES user catch-up failed; bucket remains degraded", {
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.userCatchUpInFlight = null;
+      this.scheduleRecoveryRetry({ kind: "user" });
     });
     return this.userCatchUpInFlight;
   }
@@ -46335,7 +46919,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "user" });
+        this.markUpdateBucketDegraded({ kind: "user" }, "non_progress");
         this.log.warn?.("GET_UPDATES user catch-up made no progress; bucket remains degraded", {
           cursor,
           deliveredSeq
@@ -46371,15 +46955,18 @@ class InlineSdkClient {
     const existing = this.catchUpInFlightByChatId.get(params.chatId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`chat:${params.chatId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.catchUpRequestedByChatId.get(params.chatId);
     const task = this.drainCatchUpChat(params.chatId).catch((error) => {
-      this.catchUpRequestedByChatId.delete(params.chatId);
-      this.markUpdateBucketDegraded({ kind: "chat", chatId: params.chatId, peer: params.peer });
+      this.recordCatchUpFailure({ kind: "chat", chatId: params.chatId, peer: params.peer }, error, this.catchUpRequestedByChatId.get(params.chatId) !== initialDemand);
       this.log.warn?.("GET_UPDATES chat catch-up failed; bucket remains degraded", {
         chatId: params.chatId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.catchUpInFlightByChatId.delete(params.chatId);
+      this.scheduleRecoveryRetry({ kind: "chat", chatId: params.chatId });
     });
     this.catchUpInFlightByChatId.set(params.chatId, task);
     return task;
@@ -46403,12 +46990,8 @@ class InlineSdkClient {
       if (stop) {
         if (this.catchUpRequestedByChatId.get(chatId) !== request)
           continue;
-        this.catchUpRequestedByChatId.delete(chatId);
-        return;
-      }
-      const latest = this.catchUpRequestedByChatId.get(chatId);
-      const syncedSeq = this.state.lastSeqByChatId?.[key] ?? 0;
-      if (!latest || latest.endSeq != null && latest.endSeq <= syncedSeq) {
+        if (this.degradedUpdateBuckets.has(`chat:${chatId}`))
+          return;
         this.catchUpRequestedByChatId.delete(chatId);
         return;
       }
@@ -46475,7 +47058,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+        this.markUpdateBucketDegraded({ kind: "chat", chatId, peer }, "non_progress");
         this.log.warn?.("GET_UPDATES made no progress; bucket remains degraded", {
           chatId: chatId.toString(),
           cursor,
@@ -46493,7 +47076,7 @@ class InlineSdkClient {
           continue;
         }
         if (endSeq != null && deliveredSeq < endSeq) {
-          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer }, "target_not_reached");
           this.log.warn?.("GET_UPDATES final chat page remained behind the requested target", {
             chatId: chatId.toString(),
             requestedEndSeq: endSeq,
@@ -46519,15 +47102,18 @@ class InlineSdkClient {
     const existing = this.catchUpInFlightBySpaceId.get(params.spaceId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`space:${params.spaceId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.catchUpRequestedBySpaceId.get(params.spaceId);
     const task = this.drainCatchUpSpace(params.spaceId).catch((error) => {
-      this.catchUpRequestedBySpaceId.delete(params.spaceId);
-      this.markUpdateBucketDegraded({ kind: "space", spaceId: params.spaceId });
+      this.recordCatchUpFailure({ kind: "space", spaceId: params.spaceId }, error, this.catchUpRequestedBySpaceId.get(params.spaceId) !== initialDemand);
       this.log.warn?.("GET_UPDATES space catch-up failed; bucket remains degraded", {
         spaceId: params.spaceId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.catchUpInFlightBySpaceId.delete(params.spaceId);
+      this.scheduleRecoveryRetry({ kind: "space", spaceId: params.spaceId });
     });
     this.catchUpInFlightBySpaceId.set(params.spaceId, task);
     return task;
@@ -46551,12 +47137,8 @@ class InlineSdkClient {
       if (stop) {
         if (this.catchUpRequestedBySpaceId.get(spaceId) !== request)
           continue;
-        this.catchUpRequestedBySpaceId.delete(spaceId);
-        return;
-      }
-      const latest = this.catchUpRequestedBySpaceId.get(spaceId);
-      const syncedSeq = this.state.lastSeqBySpaceId?.[key] ?? 0;
-      if (!latest || latest.endSeq != null && latest.endSeq <= syncedSeq) {
+        if (this.degradedUpdateBuckets.has(`space:${spaceId}`))
+          return;
         this.catchUpRequestedBySpaceId.delete(spaceId);
         return;
       }
@@ -46625,7 +47207,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "space", spaceId });
+        this.markUpdateBucketDegraded({ kind: "space", spaceId }, "non_progress");
         this.log.warn?.("GET_UPDATES space made no progress; bucket remains degraded", {
           spaceId: spaceId.toString(),
           cursor,
@@ -46643,7 +47225,7 @@ class InlineSdkClient {
           continue;
         }
         if (endSeq != null && deliveredSeq < endSeq) {
-          this.markUpdateBucketDegraded({ kind: "space", spaceId });
+          this.markUpdateBucketDegraded({ kind: "space", spaceId }, "target_not_reached");
           this.log.warn?.("GET_UPDATES final space page remained behind the requested target", {
             spaceId: spaceId.toString(),
             requestedEndSeq: endSeq,
@@ -46668,6 +47250,9 @@ class InlineSdkClient {
     const existing = this.peerResolutionInFlightByChatId.get(chatId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`chat:${chatId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.peerResolutionRequestedByChatId.get(chatId);
     const task = this.getChat({ chatId }).then(async (chat) => {
       const peer = chat.peer;
       if (!peer || !this.isReliableChatPeer(peer)) {
@@ -46681,14 +47266,16 @@ class InlineSdkClient {
         ...requested && !requested.toLatest && requested.endSeq != null ? { updateSeq: requested.endSeq } : {}
       });
     }).catch((error) => {
-      this.markUpdateBucketDegraded({ kind: "chat", chatId });
+      this.recordCatchUpFailure({ kind: "chat", chatId }, error, this.peerResolutionRequestedByChatId.get(chatId) !== initialDemand);
       this.log.warn?.("Unable to resolve legacy chat peer; bucket remains degraded", {
         chatId: chatId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.peerResolutionInFlightByChatId.delete(chatId);
-      this.peerResolutionRequestedByChatId.delete(chatId);
+      if (!this.degradedUpdateBuckets.has(`chat:${chatId}`))
+        this.peerResolutionRequestedByChatId.delete(chatId);
+      this.scheduleRecoveryRetry({ kind: "chat", chatId });
     });
     this.peerResolutionInFlightByChatId.set(chatId, task);
     return task;
@@ -46741,7 +47328,7 @@ class InlineSdkClient {
   }
   validateCatchUpPage(payload, startSeq, bucket) {
     if (payload.resultType !== GetUpdatesResult_ResultType.SLICE && payload.resultType !== GetUpdatesResult_ResultType.EMPTY) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "invalid_page_type");
       this.log.warn?.("GET_UPDATES returned an invalid page result type; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         resultType: payload.resultType
@@ -46750,7 +47337,7 @@ class InlineSdkClient {
     }
     const deliveredSeq = Number(payload.seq);
     if (!Number.isSafeInteger(deliveredSeq) || deliveredSeq < startSeq) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "invalid_page_cursor");
       this.log.warn?.("GET_UPDATES page moved backwards or returned an invalid seq; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         startSeq,
@@ -46762,7 +47349,7 @@ class InlineSdkClient {
     for (const update of payload.updates) {
       const seq = update.seq;
       if (!Number.isSafeInteger(seq) || seq == null || seq <= startSeq || seq > deliveredSeq || accounted.has(seq)) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "invalid_update_sequence");
         this.log.warn?.("GET_UPDATES page included an invalid or duplicate update seq; bucket remains degraded", {
           bucket: this.updateBucketKey(bucket),
           seq
@@ -46775,7 +47362,7 @@ class InlineSdkClient {
     for (const skipped of payload.skippedSequences) {
       const seq = Number(skipped.seq);
       if (!Number.isSafeInteger(seq) || seq <= startSeq || seq > deliveredSeq || accounted.has(seq)) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "invalid_skipped_sequence");
         this.log.warn?.("GET_UPDATES page included an invalid or duplicate skipped seq; bucket remains degraded", {
           bucket: this.updateBucketKey(bucket),
           seq
@@ -46791,7 +47378,7 @@ class InlineSdkClient {
           break;
         case SyncSkippedSequence_Reason.REASON_UNSPECIFIED:
         default:
-          this.markUpdateBucketDegraded(bucket);
+          this.markUpdateBucketDegraded(bucket, "unknown_skip_reason");
           this.log.warn?.("GET_UPDATES page included an unsupported skipped-sequence reason; bucket remains degraded", {
             bucket: this.updateBucketKey(bucket),
             reason: skipped.reason
@@ -46800,7 +47387,7 @@ class InlineSdkClient {
       }
     }
     if (accounted.size !== deliveredSeq - startSeq) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "unaccounted_gap");
       this.log.warn?.("GET_UPDATES page did not account for every advanced sequence; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         startSeq,
@@ -46882,7 +47469,7 @@ class InlineSdkClient {
       this.clearUpdateBucketDegraded(bucket);
       return true;
     } catch (error) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "repair_failed");
       this.log.warn?.("Authoritative update repair failed; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         error: extractErrorMessage(error)
@@ -46891,7 +47478,17 @@ class InlineSdkClient {
     }
   }
   async acceptCatchUpUpdates(updates, source, bucket) {
+    const liveDeliveries = this.liveDeliveriesByBucket.get(this.updateBucketKey(bucket));
+    if (liveDeliveries && (await Promise.all(liveDeliveries)).some((applied) => !applied)) {
+      this.markUpdateBucketDegraded(bucket, "host_unacknowledged");
+      return false;
+    }
+    if (this.closed)
+      return false;
+    const appliedThrough = this.bucketCursor(bucket);
     for (const update of updates) {
+      if (update.seq != null && update.seq > 0 && update.seq <= appliedThrough)
+        continue;
       if (update.update.oneofKind === "chatSkipPts" && source === "chat") {
         continue;
       }
@@ -46902,7 +47499,7 @@ class InlineSdkClient {
       if (accepted === true)
         continue;
       if (accepted === false) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "host_unacknowledged");
         this.log.warn?.("GET_UPDATES event was not acknowledged by the SDK host; cursor remains unchanged", {
           bucket: this.updateBucketKey(bucket),
           updateKind: update.update.oneofKind
@@ -46923,8 +47520,95 @@ class InlineSdkClient {
     }
     return true;
   }
-  markUpdateBucketDegraded(bucket) {
-    this.degradedUpdateBuckets.set(this.updateBucketKey(bucket), bucket);
+  recordCatchUpFailure(bucket, error, hasNewerDemand = false) {
+    const rpcCode = error instanceof ProtocolClientError ? error.rpcCode : undefined;
+    if (!hasNewerDemand && bucket.kind !== "user" && (rpcCode === RpcError_Code.PEER_ID_INVALID || rpcCode === RpcError_Code.CHAT_ID_INVALID || rpcCode === RpcError_Code.SPACE_ID_INVALID)) {
+      this.clearUpdateBucketDegraded(bucket);
+      if (bucket.kind === "chat") {
+        this.catchUpRequestedByChatId.delete(bucket.chatId);
+        this.peerResolutionRequestedByChatId.delete(bucket.chatId);
+      } else
+        this.catchUpRequestedBySpaceId.delete(bucket.spaceId);
+      const round = this.discoveryRound;
+      if (round) {
+        round.targets.delete(this.updateBucketKey(bucket));
+        this.tryCommitDiscoveryRound(round);
+      }
+      this.log.error?.("Sync bucket unavailable", { bucketKind: bucket.kind, reason: "access_rejected" });
+      return;
+    }
+    this.markUpdateBucketDegraded(bucket, rpcCode === RpcError_Code.RATE_LIMIT || rpcCode === 429 ? "rate_limited" : error instanceof ProtocolClientError ? error.code : "request_failed");
+  }
+  markUpdateBucketDegraded(bucket, failure = "incomplete") {
+    const key = this.updateBucketKey(bucket);
+    this.degradedUpdateBuckets.set(key, bucket);
+    const retry = this.recoveryRetries.get(key) ?? { attempt: 0, failure, reported: new Set };
+    retry.failure = failure;
+    this.recoveryRetries.set(key, retry);
+    queueMicrotask(() => this.scheduleRecoveryRetry(bucket));
+  }
+  resetRecoveryBackoff(bucket) {
+    const retry = this.recoveryRetries.get(this.updateBucketKey(bucket));
+    if (retry)
+      retry.attempt = 0;
+  }
+  cancelRecoveryRetries() {
+    clearTimeout(this.discoveryRetry?.timer);
+    this.discoveryRetry = null;
+    for (const retry of this.recoveryRetries.values())
+      clearTimeout(retry.timer);
+    this.recoveryRetries.clear();
+  }
+  scheduleDiscoveryRetry(reason) {
+    if (!this.started || this.closed || this.protocol.getDiagnostics().state !== "open")
+      return;
+    const retry = this.discoveryRetry ?? { attempt: 0, reported: new Set };
+    if (retry.timer)
+      return;
+    if (!retry.reported.has(reason)) {
+      retry.reported.add(reason);
+      this.log.error?.("Sync recovery scheduled", { bucketKind: "discovery", reason });
+    }
+    const delayMs = reason === "rate_limited" ? 60000 : Math.min(30000, 1000 * 2 ** Math.min(retry.attempt, 5));
+    retry.attempt++;
+    retry.timer = setTimeout(() => {
+      retry.timer = undefined;
+      if (this.started && !this.closed && this.protocol.getDiagnostics().state === "open") {
+        this.initializeDateCursor();
+      }
+    }, delayMs);
+    retry.timer.unref?.();
+    this.discoveryRetry = retry;
+  }
+  scheduleRecoveryRetry(bucket) {
+    const key = this.updateBucketKey(bucket);
+    if (!this.started || this.closed || !this.degradedUpdateBuckets.has(key))
+      return;
+    if (bucket.kind === "chat" && (this.catchUpInFlightByChatId.has(bucket.chatId) || this.peerResolutionInFlightByChatId.has(bucket.chatId)))
+      return;
+    if (bucket.kind === "space" && this.catchUpInFlightBySpaceId.has(bucket.spaceId))
+      return;
+    if (bucket.kind === "user" && this.userCatchUpInFlight)
+      return;
+    const retry = this.recoveryRetries.get(key) ?? { attempt: 0, failure: "incomplete", reported: new Set };
+    if (retry.timer || this.protocol.getDiagnostics().state !== "open")
+      return;
+    const delayMs = retry.failure === "rate_limited" ? 60000 : Math.min(5000, 1000 * 2 ** Math.min(retry.attempt, 3));
+    if (!retry.reported.has(retry.failure)) {
+      retry.reported.add(retry.failure);
+      this.log.error?.("Sync recovery scheduled", { bucketKind: bucket.kind, reason: retry.failure });
+    }
+    retry.attempt++;
+    retry.timer = setTimeout(() => {
+      retry.timer = undefined;
+      if (!this.started || this.closed || this.protocol.getDiagnostics().state !== "open")
+        return;
+      const pending = this.degradedUpdateBuckets.get(key);
+      if (pending)
+        this.requestCatchUpForDegradedBucket(pending);
+    }, delayMs);
+    retry.timer.unref?.();
+    this.recoveryRetries.set(key, retry);
   }
   fenceLiveCursor(bucket) {
     this.liveCursorFences.add(this.updateBucketKey(bucket));
@@ -46932,6 +47616,8 @@ class InlineSdkClient {
   clearUpdateBucketDegraded(bucket) {
     const key = this.updateBucketKey(bucket);
     this.degradedUpdateBuckets.delete(key);
+    clearTimeout(this.recoveryRetries.get(key)?.timer);
+    this.recoveryRetries.delete(key);
     this.liveCursorFences.delete(key);
     this.liveAdmittedSeqByBucket.delete(key);
   }
@@ -47538,334 +48224,6 @@ var portableCoreV1Vector = {
   aesIvHex: "a32285aa1fc31b5b3a6c5e75843de0d48393f2350d23d7ccbbc3cb7b34ce7e6c",
   recordHex: "32d1586ea457dfc80b016bab73824ee1e75f00f0fa824908302fa5dab375c8029b169848525548f61add2955845b9810fe817fcc7581efd11aaac110560a2cc78ae6a20cc6216a0b86fa0d061a57f84bacbf84af84ec31b4"
 };
-// src/sidecar/contract.ts
-var MAX_INLINE_ID = 9223372036854775807n;
-var MAX_UINT64 = 18446744073709551615n;
-var sensitiveUrlParams = new Set([
-  "access_token",
-  "auth",
-  "authorization",
-  "key",
-  "token"
-]);
-var botSettingsEventKinds = new Set([
-  "bot.chatSettings.request",
-  "bot.chatSettings.item.invoke"
-]);
-function inboundEventNeedsSenderResolution(event) {
-  return !botSettingsEventKinds.has(event.kind ?? "");
-}
-
-class SidecarError extends Error {
-  errorKind;
-  constructor(message, errorKind) {
-    super(message);
-    this.errorKind = errorKind;
-  }
-}
-function parseTarget(record2) {
-  const targetRecord = asOptionalRecord(record2.target) ?? record2;
-  const chatId = readOptionalInlineId(targetRecord, "chatId");
-  const userId = readOptionalInlineId(targetRecord, "userId");
-  if (chatId && userId)
-    throw new SidecarError("target cannot include both chatId and userId", "bad_format");
-  if (chatId)
-    return { chatId };
-  if (userId)
-    return { userId };
-  throw new SidecarError("target requires chatId or userId", "bad_format");
-}
-function normalizeUploadKind(raw, filePath) {
-  if (raw === "photo" || raw === "image")
-    return "photo";
-  if (raw === "video")
-    return "video";
-  if (raw === "voice")
-    return "voice";
-  if (raw === "document" || raw === "file")
-    return "document";
-  const lower = filePath.toLowerCase();
-  if (/\.(png|jpg|jpeg|gif|webp|heic|heif)$/.test(lower))
-    return "photo";
-  if (/\.(mp4|mov|webm)$/.test(lower))
-    return "video";
-  return "document";
-}
-function normalizeError(error, redact = defaultErrorText) {
-  if (error instanceof SidecarError) {
-    return {
-      status: statusForErrorKind(error.errorKind),
-      errorKind: error.errorKind,
-      message: redact(error)
-    };
-  }
-  const message = redact(error);
-  const lower = message.toLowerCase();
-  if (lower.includes("rate") && lower.includes("limit")) {
-    return { status: 429, errorKind: "rate_limited", message };
-  }
-  if (lower.includes("forbidden") || lower.includes("unauthorized")) {
-    return { status: 403, errorKind: "forbidden", message };
-  }
-  if (lower.includes("not found") || lower.includes("missing")) {
-    return { status: 404, errorKind: "not_found", message };
-  }
-  if (lower.includes("timeout") || lower.includes("network") || lower.includes("closed")) {
-    return { status: 503, errorKind: "transient", message };
-  }
-  return { status: 500, errorKind: "unknown", message };
-}
-function statusForErrorKind(errorKind) {
-  switch (errorKind) {
-    case "bad_format":
-      return 400;
-    case "forbidden":
-      return 403;
-    case "not_found":
-      return 404;
-    case "too_long":
-      return 413;
-    case "rate_limited":
-      return 429;
-    case "transient":
-      return 503;
-    case "unknown":
-      return 500;
-  }
-}
-function normalizeInboundEvent(event, meId, sender, meUsername) {
-  if (event.kind === "message.new" || event.kind === "message.edit") {
-    const message = asOptionalRecord(event.message);
-    return safeJson({
-      kind: event.kind,
-      chatId: event.chatId,
-      seq: event.seq,
-      date: event.date,
-      meId,
-      meUsername,
-      ...sender ? { sender } : {},
-      message: message ? normalizeMessage(message) : null
-    });
-  }
-  if (event.kind === "message.action.invoke") {
-    return safeJson({
-      ...event,
-      meId,
-      meUsername,
-      ...sender ? { sender } : {},
-      dataBase64: event.data instanceof Uint8Array ? Buffer.from(event.data).toString("base64") : typeof event.data === "string" ? event.data : ""
-    });
-  }
-  return safeJson({ ...event, meId, meUsername, ...sender ? { sender } : {} });
-}
-function normalizeMessage(message) {
-  return {
-    id: message.id,
-    fromId: message.fromId,
-    chatId: message.chatId,
-    peerId: message.peerId,
-    message: message.message ?? null,
-    out: Boolean(message.out),
-    date: message.date,
-    mentioned: Boolean(message.mentioned),
-    replyToMsgId: message.replyToMsgId ?? null,
-    entities: message.entities ?? null,
-    media: message.media ?? null,
-    attachments: message.attachments ?? null,
-    reactions: message.reactions ?? null,
-    replies: message.replies ?? null,
-    actions: message.actions ?? null,
-    rev: message.rev ?? null,
-    raw: message
-  };
-}
-function redactText(value, secrets) {
-  let text = value instanceof Error ? value.message : String(value);
-  for (const secret of secrets) {
-    const raw = typeof secret.value === "string" ? secret.value : "";
-    if (!raw)
-      continue;
-    text = text.split(raw).join(secret.label);
-  }
-  return text;
-}
-function redactUrl(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return value;
-  }
-  if (url.username)
-    url.username = "redacted";
-  if (url.password)
-    url.password = "redacted";
-  const keys = Array.from(url.searchParams.keys());
-  for (const key of keys) {
-    const normalized = key.toLowerCase();
-    if (sensitiveUrlParams.has(normalized) || normalized.includes("token")) {
-      url.searchParams.set(key, "redacted");
-    }
-  }
-  return url.toString();
-}
-function safeJson(value) {
-  if (value == null)
-    return null;
-  if (typeof value === "string" || typeof value === "boolean")
-    return value;
-  if (typeof value === "number")
-    return Number.isFinite(value) ? value : null;
-  if (typeof value === "bigint")
-    return value.toString();
-  if (value instanceof Uint8Array)
-    return Buffer.from(value).toString("base64");
-  if (Array.isArray(value))
-    return value.map(safeJson);
-  if (typeof value === "object") {
-    const out = {};
-    for (const [key, item] of Object.entries(value)) {
-      if (item !== undefined)
-        out[key] = safeJson(item);
-    }
-    return out;
-  }
-  return String(value);
-}
-function asRecord(value) {
-  const record2 = asOptionalRecord(value);
-  if (!record2)
-    throw new SidecarError("expected JSON object", "bad_format");
-  return record2;
-}
-function asOptionalRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  return value;
-}
-function readRequiredString(record2, key) {
-  const value = readOptionalString(record2, key);
-  if (!value)
-    throw new SidecarError(`missing ${key}`, "bad_format");
-  return value;
-}
-function readOptionalString(record2, key) {
-  const value = record2[key];
-  if (typeof value === "string")
-    return value.trim() || undefined;
-  if (typeof value === "bigint" || typeof value === "number")
-    return String(value);
-  return;
-}
-function readOptionalBoolean(record2, key) {
-  const value = record2[key];
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "string") {
-    if (/^(1|true|yes|on)$/i.test(value))
-      return true;
-    if (/^(0|false|no|off)$/i.test(value))
-      return false;
-  }
-  return;
-}
-function readOptionalNumber(record2, key) {
-  const value = record2[key];
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-  return;
-}
-function readRequiredInlineId(record2, key) {
-  const value = readOptionalInlineId(record2, key);
-  if (value == null)
-    throw new SidecarError(`missing ${key}`, "bad_format");
-  return value;
-}
-function readOptionalInlineId(record2, key) {
-  const value = record2[key];
-  if (value == null || value === "")
-    return;
-  return parseInlineId(value, key);
-}
-function readInlineIdArray(record2, key, maxItems, required = false) {
-  const value = record2[key];
-  if (value == null) {
-    if (required)
-      throw new SidecarError(`missing ${key}`, "bad_format");
-    return [];
-  }
-  if (!Array.isArray(value))
-    throw new SidecarError(`${key} must be an array`, "bad_format");
-  if (value.length === 0 && required)
-    throw new SidecarError(`${key} must not be empty`, "bad_format");
-  if (value.length > maxItems)
-    throw new SidecarError(`${key} supports at most ${maxItems} items`, "bad_format");
-  const ids = [];
-  const seen = new Set;
-  for (let index = 0;index < value.length; index += 1) {
-    const id = parseInlineId(value[index], `${key}[${index}]`);
-    const normalized = id.toString();
-    if (seen.has(normalized))
-      continue;
-    seen.add(normalized);
-    ids.push(id);
-  }
-  return ids;
-}
-function parseOptionalInt(value) {
-  const raw = (value || "").trim();
-  if (!raw || !/^\d+$/.test(raw))
-    return;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) ? parsed : undefined;
-}
-function parseInlineId(value, field) {
-  try {
-    if (typeof value === "number" && (!Number.isSafeInteger(value) || value <= 0)) {
-      throw new Error("unsafe number");
-    }
-    const raw = typeof value === "string" ? value.trim() : value;
-    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
-      throw new Error("invalid digits");
-    if (typeof raw !== "string" && typeof raw !== "bigint" && typeof raw !== "number") {
-      throw new Error("invalid type");
-    }
-    const parsed = BigInt(raw);
-    if (parsed <= 0n || parsed > MAX_INLINE_ID)
-      throw new Error("out of range");
-    return parsed;
-  } catch {
-    throw new SidecarError(`${field} must be a positive signed 64-bit integer`, "bad_format");
-  }
-}
-function parseUnsigned64Id(value, field) {
-  try {
-    if (typeof value === "number" && (!Number.isSafeInteger(value) || value <= 0)) {
-      throw new Error("unsafe number");
-    }
-    const raw = typeof value === "string" ? value.trim() : value;
-    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
-      throw new Error("invalid digits");
-    if (typeof raw !== "string" && typeof raw !== "bigint" && typeof raw !== "number") {
-      throw new Error("invalid type");
-    }
-    const parsed = BigInt(raw);
-    if (parsed <= 0n || parsed > MAX_UINT64)
-      throw new Error("out of range");
-    return parsed;
-  } catch {
-    throw new SidecarError(`${field} must be a positive unsigned 64-bit integer`, "bad_format");
-  }
-}
-function defaultErrorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/sidecar/user-directory.ts
 var DEFAULT_PROFILE_TTL_MS = 10 * 60000;
 var DEFAULT_MAX_PROFILES = 5000;
@@ -47873,6 +48231,7 @@ var DEFAULT_MAX_PROFILES = 5000;
 class InlineUserDirectory {
   client;
   profiles = new Map;
+  lookupTimeouts = new Map;
   hydratedChats = new Map;
   chatFetches = new Map;
   directoryExpiresAt = 0;
@@ -47897,7 +48256,7 @@ class InlineUserDirectory {
   async resolveWithProvenance(params) {
     const userId = params.userId.toString();
     const cached2 = this.getFresh(userId);
-    if (hasDisplayIdentity(cached2) && cached2.bot != null) {
+    if (cached2?.bot != null) {
       return { profile: cached2, provenanceVerified: true };
     }
     if (params.direct) {
@@ -47910,7 +48269,7 @@ class InlineUserDirectory {
     } else {
       const chatHydrated = await this.hydrateChat(params.chatId);
       const participant = this.getFresh(userId);
-      if (hasDisplayIdentity(participant)) {
+      if (participant?.bot != null || hasDisplayIdentity(participant)) {
         return {
           profile: participant,
           provenanceVerified: chatHydrated || participant.bot != null
@@ -47979,7 +48338,7 @@ class InlineUserDirectory {
     if (existing)
       return existing;
     const fetch2 = (async () => {
-      const result = await this.client.invokeUncheckedRaw(Method.GET_CHAT_PARTICIPANTS, {
+      const result = await this.invokeLookup(Method.GET_CHAT_PARTICIPANTS, {
         oneofKind: "getChatParticipants",
         getChatParticipants: { chatId }
       });
@@ -48000,13 +48359,24 @@ class InlineUserDirectory {
     this.chatFetches.set(key, fetch2);
     return await fetch2;
   }
+  async invokeLookup(method, input) {
+    const timeoutMs = this.lookupTimeouts.get(method) ?? 1500;
+    try {
+      return await this.client.invokeUncheckedRaw(method, input, { timeoutMs });
+    } catch (error) {
+      if (error instanceof ProtocolClientError && error.code === "timeout") {
+        this.lookupTimeouts.set(method, Math.max(this.lookupTimeouts.get(method) ?? 0, Math.min(30000, timeoutMs * 2)));
+      }
+      throw error;
+    }
+  }
   async hydrateDirectory() {
     if (this.directoryExpiresAt > this.now())
       return true;
     if (this.directoryFetch)
       return this.directoryFetch;
     const fetch2 = (async () => {
-      const result = await this.client.invokeUncheckedRaw(Method.GET_CHATS, {
+      const result = await this.invokeLookup(Method.GET_CHATS, {
         oneofKind: "getChats",
         getChats: {}
       });
@@ -48244,8 +48614,8 @@ var meUsername = null;
 var connectError = null;
 var connectAttempts = 0;
 var nextConnectRetryAt = null;
-var consumer = null;
-var consumerWaiters = [];
+var inboundStream = new InboundStream;
+var inboundAbort = new AbortController;
 var clientOptions = {
   token,
   baseUrl,
@@ -48321,11 +48691,15 @@ async function connectClientLoop() {
 }
 async function consumeEvents() {
   try {
-    for await (const event of client.events()) {
-      const senderResolution = inboundEventNeedsSenderResolution(event) ? await resolveInboundSender(event) : { provenanceVerified: true };
-      const normalized = normalizeInboundEvent(event, meId, senderResolution.profile, meUsername);
-      await deliver(senderResolution.provenanceVerified ? normalized : { ...asRecord(normalized), _inlineSenderProvenanceVerified: false });
-    }
+    await client.consumeEvents(async (event) => {
+      await deliverInboundEvent(event, {
+        meId,
+        meUsername,
+        signal: inboundAbort.signal,
+        resolveSender: resolveInboundSender,
+        deliver
+      });
+    });
   } catch (error) {
     if (!stopping) {
       reportHermesPluginError("inbound.loop", error, { handled: false });
@@ -49166,6 +49540,10 @@ class MockInlineClient {
       calls: this.calls
     };
   }
+  async consumeEvents(handler) {
+    for await (const event of this.events())
+      await handler(event);
+  }
   events() {
     return {
       [Symbol.asyncIterator]: () => ({
@@ -49458,41 +49836,15 @@ server.listen(port, bind, () => {
 });
 setupShutdown();
 function attachConsumer(res) {
-  if (consumer) {
-    consumer.end();
-    consumer = null;
-  }
   res.writeHead(200, {
     "content-type": "application/x-ndjson; charset=utf-8",
     "cache-control": "no-cache",
     connection: "keep-alive"
   });
-  consumer = res;
-  const waiters = consumerWaiters;
-  consumerWaiters = [];
-  for (const resolve of waiters)
-    resolve();
-  res.on("close", () => {
-    if (consumer === res)
-      consumer = null;
-  });
+  inboundStream.attach(res);
 }
 async function deliver(event) {
-  while (!stopping) {
-    if (!consumer) {
-      await new Promise((resolve) => consumerWaiters.push(resolve));
-      continue;
-    }
-    try {
-      const ok = consumer.write(JSON.stringify(event) + `
-`);
-      if (!ok)
-        await once(consumer, "drain");
-      return;
-    } catch {
-      consumer = null;
-    }
-  }
+  await inboundStream.deliver(event);
 }
 function inputPeerFromTarget(target) {
   if ("chatId" in target) {
@@ -49593,6 +49945,9 @@ function redactError(error) {
 }
 function log(level, args) {
   const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(safeJson(arg))).join(" ");
+  if (level === "error" && (args[0] === "Sync recovery scheduled" || args[0] === "Sync bucket unavailable" || args[0] === "Sync discovery unavailable")) {
+    reportHermesPluginError("sdk.sync_recovery", new Error(redactError(message)));
+  }
   console.error(`inline-sidecar:${level}: ${redactError(message)}`);
 }
 function clampRetryMs(value, fallback) {
@@ -49643,8 +49998,8 @@ async function shutdown(code) {
     return;
   stopping = true;
   try {
-    consumer?.end();
-    consumer = null;
+    inboundAbort.abort();
+    inboundStream.close();
     server.close();
     await client.close();
   } catch (error) {