memeloop 0.1.3 → 0.2.0

package/dist/device-network.cjs

@@ -24,6 +24,8 @@ __export(device_network_entry_exports, {
   DEVICE_ORCHESTRATION_PROTOCOL: () => DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_PROTOCOL: () => DEVICE_PAIRING_INVITE_PROTOCOL,
   DEVICE_PAIRING_INVITE_TTL_MS: () => DEVICE_PAIRING_INVITE_TTL_MS,
+  DeviceCloudConnectionCoordinator: () => DeviceCloudConnectionCoordinator,
+  JsonFrameError: () => JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE: () => LIBP2P_RPC_REQUEST_TYPE,
   LIBP2P_RPC_RESPONSE_TYPE: () => LIBP2P_RPC_RESPONSE_TYPE,
   LIBP2P_SYNC_REQUEST_TYPE: () => LIBP2P_SYNC_REQUEST_TYPE,
@@ -31,13 +33,19 @@ __export(device_network_entry_exports, {
   Libp2pDeviceSyncTransport: () => Libp2pDeviceSyncTransport,
   LocalTrustDeviceAuthorizer: () => LocalTrustDeviceAuthorizer,
   MemoryDeviceNetworkService: () => MemoryDeviceNetworkService,
+  MemoryDeviceSyncStateStore: () => MemoryDeviceSyncStateStore,
   PeerNodeSyncAdapter: () => PeerNodeSyncAdapter,
   attachmentBlobFromWire: () => attachmentBlobFromWire,
+  canonicalDevicePairingInviteBytes: () => canonicalDevicePairingInviteBytes,
+  computeMissingVersionRanges: () => computeMissingVersionRanges,
   createDeviceOrchestrationStreamHandler: () => createDeviceOrchestrationStreamHandler,
   createDeviceOrchestrationTransport: () => createDeviceOrchestrationTransport,
   createDevicePairingInvite: () => createDevicePairingInvite,
+  createJsonFrameReader: () => createJsonFrameReader,
   decodeAttachmentBlobRpc: () => decodeAttachmentBlobRpc,
   encodeDevicePairingInvite: () => encodeDevicePairingInvite,
+  encodeJsonFrame: () => encodeJsonFrame,
+  encodeJsonFrames: () => encodeJsonFrames,
   isConversationMeta: () => isConversationMeta,
   isLibp2pRpcRequest: () => isLibp2pRpcRequest,
   isLibp2pRpcResponse: () => isLibp2pRpcResponse,
@@ -48,6 +56,224 @@ __export(device_network_entry_exports, {
 });
 module.exports = __toCommonJS(device_network_entry_exports);
 
+// src/device-network/deviceCloudConnectionCoordinator.ts
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 6e4;
+var DEFAULT_INITIAL_BACKOFF_MS = 1e3;
+var DEFAULT_MAX_BACKOFF_MS = 6e4;
+var DEFAULT_JITTER_RATIO = 0.2;
+function emptyComponents() {
+  return {
+    authorizer: "not-run",
+    registration: "not-run",
+    relay: "not-run",
+    heartbeat: "not-run",
+    directory: "not-run"
+  };
+}
+function assertNonNegativeFinite(value, name) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${name} must be a finite non-negative number`);
+  }
+}
+var DeviceCloudConnectionCoordinator = class {
+  constructor(options) {
+    this.options = options;
+    this.configuration = options.configuration;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.initialBackoffMs = options.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+    this.maxBackoffMs = options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    this.jitterRatio = options.jitterRatio ?? DEFAULT_JITTER_RATIO;
+    this.now = options.now ?? Date.now;
+    this.random = options.random ?? Math.random;
+    assertNonNegativeFinite(this.heartbeatIntervalMs, "heartbeatIntervalMs");
+    assertNonNegativeFinite(this.initialBackoffMs, "initialBackoffMs");
+    assertNonNegativeFinite(this.maxBackoffMs, "maxBackoffMs");
+    assertNonNegativeFinite(this.jitterRatio, "jitterRatio");
+    if (this.jitterRatio > 1) throw new TypeError("jitterRatio must not exceed 1");
+    this.resetSnapshot();
+  }
+  configuration;
+  generation = 0;
+  controller = new AbortController();
+  timer;
+  inFlight;
+  started = false;
+  consecutiveFailures = 0;
+  snapshotValue = {
+    status: "not-configured",
+    generation: 0,
+    components: emptyComponents()
+  };
+  heartbeatIntervalMs;
+  initialBackoffMs;
+  maxBackoffMs;
+  jitterRatio;
+  now;
+  random;
+  get snapshot() {
+    return {
+      ...this.snapshotValue,
+      components: { ...this.snapshotValue.components }
+    };
+  }
+  async start() {
+    if (this.started) return this.runNow();
+    this.started = true;
+    await this.runNow();
+  }
+  async stop() {
+    this.started = false;
+    this.clearTimer();
+    this.controller.abort(new Error("device cloud coordinator stopped"));
+    await this.inFlight?.catch(() => void 0);
+  }
+  async setConfiguration(configuration) {
+    this.configuration = configuration;
+    this.generation += 1;
+    this.consecutiveFailures = 0;
+    this.clearTimer();
+    this.controller.abort(new Error("device cloud configuration changed"));
+    this.controller = new AbortController();
+    this.inFlight = void 0;
+    this.resetSnapshot();
+    if (this.started && this.options.adapter.isConfigured(configuration)) await this.runNow();
+  }
+  runNow() {
+    if (this.inFlight) return this.inFlight;
+    if (!this.options.adapter.isConfigured(this.configuration)) {
+      this.resetSnapshot();
+      return Promise.resolve();
+    }
+    const generation = this.generation;
+    const configuration = this.configuration;
+    const signal = this.controller.signal;
+    const run = this.maintain(configuration, generation, signal);
+    const tracked = run.finally(() => {
+      if (this.inFlight === tracked) this.inFlight = void 0;
+    });
+    this.inFlight = tracked;
+    return tracked;
+  }
+  async maintain(configuration, generation, signal) {
+    if (!this.isCurrent(generation, signal)) return;
+    await this.updateSnapshot(generation, {
+      status: "connecting",
+      lastError: void 0,
+      nextRetryAt: void 0
+    });
+    try {
+      if (this.snapshotValue.components.authorizer !== "ready") {
+        await this.runStep("authorizer", generation, signal, () => this.options.adapter.ensureAuthorizer(configuration, signal));
+      }
+      if (this.snapshotValue.components.registration !== "ready") {
+        await this.runStep("registration", generation, signal, () => this.options.adapter.registerDevice(configuration, signal));
+      }
+      let relayError;
+      try {
+        await this.runStep("relay", generation, signal, () => this.options.adapter.ensureRelay(configuration, signal));
+      } catch (error) {
+        relayError = error;
+        this.options.logWarning?.("Cloud relay maintenance failed", error);
+      }
+      await this.runStep("heartbeat", generation, signal, () => this.options.adapter.heartbeat(configuration, signal));
+      let directoryError;
+      try {
+        await this.runStep("directory", generation, signal, () => this.options.adapter.syncDirectory(configuration, signal));
+      } catch (error) {
+        directoryError = error;
+        this.options.logWarning?.("Cloud directory synchronization failed", error);
+      }
+      if (!this.isCurrent(generation, signal)) return;
+      this.consecutiveFailures = 0;
+      const relayRequired = this.options.adapter.relayRequiredForOnline(configuration);
+      await this.updateSnapshot(generation, {
+        status: directoryError || relayRequired && relayError ? "degraded" : "online",
+        lastError: directoryError ?? relayError,
+        nextRetryAt: this.now() + this.heartbeatIntervalMs
+      });
+      this.schedule(this.heartbeatIntervalMs, generation);
+    } catch (error) {
+      if (!this.isCurrent(generation, signal)) return;
+      this.consecutiveFailures += 1;
+      if (this.snapshotValue.components.heartbeat === "failed") {
+        this.snapshotValue.components.registration = "not-run";
+      }
+      const status = this.options.adapter.classifyError?.(error) ?? "offline";
+      const delay = this.backoffDelay();
+      await this.updateSnapshot(generation, {
+        status,
+        lastError: error,
+        nextRetryAt: this.now() + delay
+      });
+      this.schedule(delay, generation);
+      throw error;
+    }
+  }
+  async runStep(component, generation, signal, operation) {
+    if (!this.isCurrent(generation, signal)) return;
+    await this.setComponent(component, "pending", generation);
+    try {
+      const result = await operation();
+      if (!this.isCurrent(generation, signal)) return;
+      await result?.commit?.();
+      if (!this.isCurrent(generation, signal)) return;
+      await this.setComponent(component, "ready", generation);
+    } catch (error) {
+      if (this.isCurrent(generation, signal)) await this.setComponent(component, "failed", generation);
+      throw error;
+    }
+  }
+  backoffDelay() {
+    const exponential = Math.min(
+      this.maxBackoffMs,
+      this.initialBackoffMs * 2 ** Math.max(0, this.consecutiveFailures - 1)
+    );
+    const jitter = exponential * this.jitterRatio * (this.random() * 2 - 1);
+    return Math.max(0, Math.round(exponential + jitter));
+  }
+  schedule(delayMs, generation) {
+    if (!this.started || generation !== this.generation) return;
+    this.clearTimer();
+    this.timer = setTimeout(() => {
+      if (generation !== this.generation) return;
+      void this.runNow().catch((error) => {
+        this.options.logWarning?.("Cloud maintenance failed", error);
+      });
+    }, delayMs);
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  isCurrent(generation, signal) {
+    return generation === this.generation && !signal.aborted;
+  }
+  async setComponent(component, status, generation) {
+    if (generation !== this.generation) return;
+    this.snapshotValue = {
+      ...this.snapshotValue,
+      components: { ...this.snapshotValue.components, [component]: status }
+    };
+    await this.emit();
+  }
+  async updateSnapshot(generation, update) {
+    if (generation !== this.generation) return;
+    this.snapshotValue = { ...this.snapshotValue, ...update };
+    await this.emit();
+  }
+  resetSnapshot() {
+    this.snapshotValue = {
+      status: this.options.adapter.isConfigured(this.configuration) ? "offline" : "not-configured",
+      generation: this.generation,
+      components: emptyComponents()
+    };
+    void this.emit();
+  }
+  async emit() {
+    await this.options.onStatus?.(this.snapshot);
+  }
+};
+
 // src/orchestration/errors.ts
 var OrchestrationError = class extends Error {
   code;
@@ -76,9 +302,222 @@ var OrchestrationError = class extends Error {
   }
 };
 
+// src/device-network/jsonFrame.ts
+var JsonFrameError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "JsonFrameError";
+    this.code = code;
+  }
+};
+var HEADER_BYTES = 4;
+var MAX_UINT32 = 4294967295;
+function assertPositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+}
+function validateMaxPayloadBytes(maxPayloadBytes) {
+  assertPositiveInteger(maxPayloadBytes, "maxPayloadBytes");
+  if (maxPayloadBytes > MAX_UINT32) {
+    throw new TypeError("maxPayloadBytes must fit in an unsigned 32-bit frame length");
+  }
+}
+function encodeJsonFrame(value, maxPayloadBytes = MAX_UINT32) {
+  validateMaxPayloadBytes(maxPayloadBytes);
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch (error) {
+    throw new JsonFrameError("INVALID_JSON", "JSON frame value cannot be serialized", {
+      cause: error
+    });
+  }
+  if (serialized === void 0) {
+    throw new JsonFrameError("INVALID_JSON", "JSON frame value cannot be serialized");
+  }
+  const payload = new TextEncoder().encode(serialized);
+  if (payload.byteLength > maxPayloadBytes) {
+    throw new JsonFrameError(
+      "FRAME_TOO_LARGE",
+      `JSON frame payload exceeds ${maxPayloadBytes} bytes`
+    );
+  }
+  const frame = new Uint8Array(HEADER_BYTES + payload.byteLength);
+  new DataView(frame.buffer, frame.byteOffset, HEADER_BYTES).setUint32(0, payload.byteLength, false);
+  frame.set(payload, HEADER_BYTES);
+  return frame;
+}
+async function* encodeJsonFrames(values, maxPayloadBytes = MAX_UINT32) {
+  for await (const value of values) {
+    yield encodeJsonFrame(value, maxPayloadBytes);
+  }
+}
+function concatBytes(left, right) {
+  if (left.byteLength === 0) return right.slice();
+  if (right.byteLength === 0) return left;
+  const combined = new Uint8Array(left.byteLength + right.byteLength);
+  combined.set(left);
+  combined.set(right, left.byteLength);
+  return combined;
+}
+function abortedError(signal) {
+  return new JsonFrameError("ABORTED", "JSON frame reading was aborted", {
+    cause: signal?.reason
+  });
+}
+async function readNextChunk(iterator, idleDeadline, totalDeadline, signal) {
+  if (signal?.aborted) throw abortedError(signal);
+  const now = Date.now();
+  const deadline = totalDeadline === void 0 ? idleDeadline : Math.min(idleDeadline, totalDeadline);
+  if (deadline <= now) {
+    throw new JsonFrameError(
+      totalDeadline !== void 0 && totalDeadline <= idleDeadline ? "TOTAL_TIMEOUT" : "IDLE_TIMEOUT",
+      totalDeadline !== void 0 && totalDeadline <= idleDeadline ? "JSON frame total timeout expired" : "JSON frame idle timeout expired"
+    );
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      finish(() => {
+        reject(abortedError(signal));
+      });
+    };
+    const timer = setTimeout(() => {
+      const currentTime = Date.now();
+      const totalExpired = totalDeadline !== void 0 && currentTime >= totalDeadline;
+      finish(() => {
+        reject(
+          new JsonFrameError(
+            totalExpired ? "TOTAL_TIMEOUT" : "IDLE_TIMEOUT",
+            totalExpired ? "JSON frame total timeout expired" : "JSON frame idle timeout expired"
+          )
+        );
+      });
+    }, Math.max(1, deadline - now));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    void iterator.next().then(
+      (result) => {
+        finish(() => {
+          resolve(result);
+        });
+      },
+      (error) => {
+        finish(() => {
+          reject(
+            error instanceof Error ? error : new Error("JSON frame source failed", {
+              cause: error
+            })
+          );
+        });
+      }
+    );
+  });
+}
+function createJsonFrameReader(source, options) {
+  validateMaxPayloadBytes(options.maxPayloadBytes);
+  assertPositiveInteger(options.idleTimeoutMs, "idleTimeoutMs");
+  assertPositiveInteger(options.totalTimeoutMs, "totalTimeoutMs");
+  return (async function* readFrames() {
+    const iterator = source[Symbol.asyncIterator]();
+    let buffered = new Uint8Array(0);
+    let expectedPayloadBytes;
+    let idleDeadline = Date.now() + options.idleTimeoutMs;
+    let totalDeadline;
+    let abortCalled = false;
+    const abortOnce = async (error) => {
+      if (abortCalled) return;
+      abortCalled = true;
+      await Promise.resolve(options.abort?.(error)).catch(() => void 0);
+    };
+    try {
+      for (; ; ) {
+        if (expectedPayloadBytes === void 0 && buffered.byteLength >= HEADER_BYTES) {
+          expectedPayloadBytes = new DataView(
+            buffered.buffer,
+            buffered.byteOffset,
+            HEADER_BYTES
+          ).getUint32(0, false);
+          buffered = buffered.slice(HEADER_BYTES);
+          totalDeadline ??= Date.now() + options.totalTimeoutMs;
+          if (expectedPayloadBytes > options.maxPayloadBytes) {
+            throw new JsonFrameError(
+              "FRAME_TOO_LARGE",
+              `JSON frame payload exceeds ${options.maxPayloadBytes} bytes`
+            );
+          }
+        }
+        if (expectedPayloadBytes !== void 0 && buffered.byteLength >= expectedPayloadBytes) {
+          const payload = buffered.slice(0, expectedPayloadBytes);
+          buffered = buffered.slice(expectedPayloadBytes);
+          expectedPayloadBytes = void 0;
+          totalDeadline = buffered.byteLength > 0 ? Date.now() + options.totalTimeoutMs : void 0;
+          let text;
+          try {
+            text = new TextDecoder("utf-8", { fatal: true }).decode(payload);
+          } catch (error) {
+            throw new JsonFrameError("INVALID_UTF8", "JSON frame payload is not valid UTF-8", {
+              cause: error
+            });
+          }
+          let value;
+          try {
+            value = JSON.parse(text);
+          } catch (error) {
+            throw new JsonFrameError("INVALID_JSON", "JSON frame payload is not valid JSON", {
+              cause: error
+            });
+          }
+          yield value;
+          idleDeadline = Date.now() + options.idleTimeoutMs;
+          continue;
+        }
+        const result = await readNextChunk(
+          iterator,
+          idleDeadline,
+          totalDeadline,
+          options.signal
+        );
+        if (result.done) {
+          if (buffered.byteLength > 0 || expectedPayloadBytes !== void 0) {
+            throw new JsonFrameError("TRUNCATED_FRAME", "JSON frame stream ended mid-frame");
+          }
+          return;
+        }
+        if (!(result.value instanceof Uint8Array)) {
+          throw new TypeError("JSON frame source must yield Uint8Array chunks");
+        }
+        if (result.value.byteLength === 0) continue;
+        const now = Date.now();
+        idleDeadline = now + options.idleTimeoutMs;
+        totalDeadline ??= now + options.totalTimeoutMs;
+        buffered = concatBytes(buffered, result.value);
+      }
+    } catch (error) {
+      const frameError = error instanceof JsonFrameError ? error : new JsonFrameError("ABORTED", "JSON frame source failed", { cause: error });
+      await abortOnce(frameError);
+      throw frameError;
+    } finally {
+      void iterator.return?.().catch(() => void 0);
+    }
+  })();
+}
+
 // src/device-network/deviceOrchestrationTransport.ts
-var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/1.0.0";
+var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/2.0.0";
 var DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
+var REQUEST_IDLE_TIMEOUT_MS = 1e4;
+var REQUEST_TOTAL_TIMEOUT_MS = 3e4;
+var WATCH_IDLE_TIMEOUT_MS = 9e4;
+var WATCH_BOOKMARK_INTERVAL_MS = 3e4;
 function orchestrationTransportError(code, message) {
   return new OrchestrationError({
     code,
@@ -91,65 +530,6 @@ function assertFrameLimit(limit) {
     throw new TypeError("maxFrameBytes must be a safe integer of at least 256");
   }
 }
-async function* encodeLines(values, maxFrameBytes) {
-  const encoder = new TextEncoder();
-  for await (const value of values) {
-    const frame = encoder.encode(`${JSON.stringify(value)}
-`);
-    if (frame.byteLength > maxFrameBytes) {
-      throw orchestrationTransportError(
-        "EXHAUSTED",
-        `device orchestration frame exceeds ${maxFrameBytes} bytes`
-      );
-    }
-    yield frame;
-  }
-}
-async function* decodeLines(source, maxFrameBytes) {
-  const decoder = new TextDecoder();
-  let buffered = "";
-  for await (const chunk of source) {
-    buffered += decoder.decode(chunk, { stream: true });
-    for (; ; ) {
-      const newline = buffered.indexOf("\n");
-      if (newline < 0) break;
-      const line = buffered.slice(0, newline);
-      buffered = buffered.slice(newline + 1);
-      if (!line) continue;
-      if (new TextEncoder().encode(line).byteLength > maxFrameBytes) {
-        throw orchestrationTransportError(
-          "EXHAUSTED",
-          `device orchestration frame exceeds ${maxFrameBytes} bytes`
-        );
-      }
-      try {
-        yield JSON.parse(line);
-      } catch {
-        throw orchestrationTransportError(
-          "INVALID",
-          "device orchestration stream contains invalid JSON"
-        );
-      }
-    }
-    if (new TextEncoder().encode(buffered).byteLength > maxFrameBytes) {
-      throw orchestrationTransportError(
-        "EXHAUSTED",
-        `device orchestration frame exceeds ${maxFrameBytes} bytes`
-      );
-    }
-  }
-  buffered += decoder.decode();
-  if (buffered.trim()) {
-    try {
-      yield JSON.parse(buffered);
-    } catch {
-      throw orchestrationTransportError(
-        "INVALID",
-        "device orchestration stream contains invalid trailing JSON"
-      );
-    }
-  }
-}
 function throwIfAborted(signal) {
   if (signal?.aborted) {
     throw orchestrationTransportError("CANCELLED", "device orchestration request was cancelled");
@@ -168,11 +548,41 @@ async function openAuthenticatedStream(options) {
 }
 async function writeRequest(stream, request, grant, maxFrameBytes) {
   const envelope = {
-    type: "memeloop-device-orchestration-request-v1",
+    type: "memeloop-device-orchestration-request-v2",
     request,
     ...grant ? { grant } : {}
   };
-  await stream.sink(encodeLines([envelope], maxFrameBytes));
+  await stream.sink(encodeJsonFrames([envelope], maxFrameBytes));
+}
+function abortStreamOnce(stream) {
+  let aborted = false;
+  return async (error) => {
+    if (aborted) return;
+    aborted = true;
+    await stream.abort(error);
+  };
+}
+function frameReader(stream, maxFrameBytes, idleTimeoutMs, signal, abort) {
+  return createJsonFrameReader(stream.source, {
+    maxPayloadBytes: maxFrameBytes,
+    idleTimeoutMs,
+    totalTimeoutMs: REQUEST_TOTAL_TIMEOUT_MS,
+    signal,
+    abort
+  });
+}
+function mapFrameError(error) {
+  if (!(error instanceof JsonFrameError)) throw error;
+  if (error.code === "ABORTED") {
+    throw orchestrationTransportError("CANCELLED", error.message);
+  }
+  if (error.code === "FRAME_TOO_LARGE") {
+    throw orchestrationTransportError("EXHAUSTED", error.message);
+  }
+  if (error.code === "IDLE_TIMEOUT" || error.code === "TOTAL_TIMEOUT") {
+    throw orchestrationTransportError("UNAVAILABLE", error.message);
+  }
+  throw orchestrationTransportError("INVALID", error.message);
 }
 function createDeviceOrchestrationTransport(options) {
   const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
@@ -181,8 +591,9 @@ function createDeviceOrchestrationTransport(options) {
     async request(request, transportOptions = {}) {
       throwIfAborted(transportOptions.signal);
       const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
       const closeOnAbort = () => {
-        void stream.close();
+        void abort(orchestrationTransportError("CANCELLED", "device orchestration request was cancelled"));
       };
       transportOptions.signal?.addEventListener("abort", closeOnAbort, {
         once: true
@@ -190,7 +601,13 @@ function createDeviceOrchestrationTransport(options) {
       try {
         await writeRequest(stream, request, grant, maxFrameBytes);
         let response;
-        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+        for await (const value of frameReader(
+          stream,
+          maxFrameBytes,
+          REQUEST_IDLE_TIMEOUT_MS,
+          transportOptions.signal,
+          abort
+        )) {
           if (response) {
             throw orchestrationTransportError(
               "INVALID",
@@ -207,6 +624,9 @@ function createDeviceOrchestrationTransport(options) {
           );
         }
         return response;
+      } catch (error) {
+        if (error instanceof JsonFrameError) await abort(error);
+        mapFrameError(error);
       } finally {
         transportOptions.signal?.removeEventListener("abort", closeOnAbort);
         await stream.close().catch(() => void 0);
@@ -215,19 +635,29 @@ function createDeviceOrchestrationTransport(options) {
     async *watch(request, transportOptions = {}) {
       throwIfAborted(transportOptions.signal);
       const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
       const closeOnAbort = () => {
-        void stream.close();
+        void abort(orchestrationTransportError("CANCELLED", "device orchestration watch was cancelled"));
       };
       transportOptions.signal?.addEventListener("abort", closeOnAbort, {
         once: true
       });
       try {
         await writeRequest(stream, request, grant, maxFrameBytes);
-        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+        for await (const value of frameReader(
+          stream,
+          maxFrameBytes,
+          WATCH_IDLE_TIMEOUT_MS,
+          transportOptions.signal,
+          abort
+        )) {
           throwIfAborted(transportOptions.signal);
           yield value;
         }
         throwIfAborted(transportOptions.signal);
+      } catch (error) {
+        if (error instanceof JsonFrameError) await abort(error);
+        mapFrameError(error);
       } finally {
         transportOptions.signal?.removeEventListener("abort", closeOnAbort);
         await stream.close().catch(() => void 0);
@@ -236,15 +666,22 @@ function createDeviceOrchestrationTransport(options) {
   };
 }
 async function readSingleRequest(stream, maxFrameBytes) {
+  const abort = abortStreamOnce(stream);
   let envelope;
-  for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+  for await (const value of frameReader(
+    stream,
+    maxFrameBytes,
+    REQUEST_IDLE_TIMEOUT_MS,
+    void 0,
+    abort
+  )) {
     if (envelope) {
       throw orchestrationTransportError(
         "INVALID",
         "device orchestration stream accepts exactly one request"
       );
     }
-    if (value === null || typeof value !== "object" || Array.isArray(value) || value.type !== "memeloop-device-orchestration-request-v1" || value.request === null || typeof value.request !== "object") {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || value.type !== "memeloop-device-orchestration-request-v2" || value.request === null || typeof value.request !== "object") {
       throw orchestrationTransportError(
         "INVALID",
         "device orchestration request envelope is invalid"
@@ -257,6 +694,41 @@ async function readSingleRequest(stream, maxFrameBytes) {
   }
   return envelope;
 }
+async function* withWatchBookmarks(source, request, signal) {
+  const iterator = source[Symbol.asyncIterator]();
+  let pending = iterator.next();
+  try {
+    for (; ; ) {
+      const result = await Promise.race([
+        pending.then((value) => ({ kind: "value", value })),
+        new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            resolve({ kind: "bookmark" });
+          }, WATCH_BOOKMARK_INTERVAL_MS);
+          signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve({ kind: "bookmark" });
+          }, { once: true });
+        })
+      ]);
+      if (signal.aborted) return;
+      if (result.kind === "bookmark") {
+        yield {
+          protocol: request.protocol,
+          requestId: request.requestId,
+          ok: true,
+          result: { type: "BOOKMARK", resourceVersion: String(Date.now()) }
+        };
+        continue;
+      }
+      if (result.value.done) return;
+      yield result.value.value;
+      pending = iterator.next();
+    }
+  } finally {
+    void iterator.return?.();
+  }
+}
 function createDeviceOrchestrationStreamHandler(options) {
   const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
   assertFrameLimit(maxFrameBytes);
@@ -271,10 +743,13 @@ function createDeviceOrchestrationStreamHandler(options) {
       const handler = await options.resolveHandler(remotePeerId);
       if (request.operation === "watch") {
         await stream.sink(
-          encodeLines(handler.watch(request, { signal: abort.signal }), maxFrameBytes)
+          encodeJsonFrames(
+            withWatchBookmarks(handler.watch(request, { signal: abort.signal }), request, abort.signal),
+            maxFrameBytes
+          )
         );
       } else {
-        await stream.sink(encodeLines([await handler.request(request)], maxFrameBytes));
+        await stream.sink(encodeJsonFrames([await handler.request(request)], maxFrameBytes));
       }
     } finally {
       abort.abort();
@@ -283,9 +758,23 @@ function createDeviceOrchestrationStreamHandler(options) {
   };
 }
 
+// src/device-network/deviceSyncStateStore.ts
+var MemoryDeviceSyncStateStore = class {
+  versionVector;
+  constructor(initial = {}) {
+    this.versionVector = { ...initial };
+  }
+  async loadVersionVector() {
+    return { ...this.versionVector };
+  }
+  async saveVersionVector(versionVector) {
+    this.versionVector = { ...versionVector };
+  }
+};
+
 // src/device-network/libp2pSyncProtocol.ts
-var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v1";
-var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v1";
+var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v2";
+var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v2";
 var syncMethods = /* @__PURE__ */ new Set([
   "exchangeVersionVector",
   "pullMissingMetadata",
@@ -345,8 +834,11 @@ var Libp2pDeviceSyncTransport = class {
   exchangeVersionVector(peerId, localVersion) {
     return this.request(peerId, "exchangeVersionVector", { localVersion });
   }
-  pullMissingMetadata(peerId, sinceVersion) {
-    return this.request(peerId, "pullMissingMetadata", { sinceVersion });
+  pullMissingMetadata(peerId, sinceVersion, cursor) {
+    return this.request(peerId, "pullMissingMetadata", {
+      sinceVersion,
+      cursor
+    });
   }
   pullMissingMessages(peerId, conversationId, knownMessageIds) {
     return this.request(peerId, "pullMissingMessages", { conversationId, knownMessageIds });
@@ -357,7 +849,7 @@ var Libp2pDeviceSyncTransport = class {
   }
   async request(peerId, method, parameters) {
     const grant = await this.grantProvider?.(peerId);
-    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/1.0.0", grant);
+    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/2.0.0", grant);
     const request = {
       type: LIBP2P_SYNC_REQUEST_TYPE,
       id: crypto.randomUUID(),
@@ -365,31 +857,34 @@ var Libp2pDeviceSyncTransport = class {
       params: parameters,
       grant
     };
-    await writeJsonToStream(stream, request);
-    const response = await readJsonFromStream(stream);
-    await stream.close();
-    if (!isLibp2pSyncResponse(response)) throw new Error("invalid_sync_response");
-    if (response.id !== request.id) throw new Error("sync_response_id_mismatch");
-    if (!response.ok) throw new Error(response.error);
-    return response.result;
+    try {
+      await stream.sink(encodeJsonFrames([request], 16 * 1024 * 1024));
+      let response;
+      for await (const value of createJsonFrameReader(stream.source, {
+        maxPayloadBytes: 16 * 1024 * 1024,
+        idleTimeoutMs: 15e3,
+        totalTimeoutMs: 12e4,
+        abort: async (error) => stream.abort(error)
+      })) {
+        if (response !== void 0) throw new Error("sync_response_multiple");
+        response = value;
+      }
+      if (!isLibp2pSyncResponse(response)) throw new Error("invalid_sync_response");
+      if (response.id !== request.id) throw new Error("sync_response_id_mismatch");
+      if (!response.ok) throw new Error(response.error);
+      return response.result;
+    } catch (error) {
+      if (error instanceof JsonFrameError) await stream.abort(error);
+      throw error;
+    } finally {
+      await stream.close().catch(() => void 0);
+    }
   }
 };
-async function writeJsonToStream(stream, message) {
-  const payload = new TextEncoder().encode(JSON.stringify(message));
-  await stream.sink((async function* () {
-    yield payload;
-  })());
-}
-async function readJsonFromStream(stream) {
-  const reader = stream.source[Symbol.asyncIterator]();
-  const result = await reader.next();
-  if (result.done || !result.value) throw new Error("sync_response_missing");
-  return JSON.parse(new TextDecoder().decode(result.value));
-}
 
 // src/device-network/libp2pRpcProtocol.ts
-var LIBP2P_RPC_REQUEST_TYPE = "memeloop-rpc-request-v1";
-var LIBP2P_RPC_RESPONSE_TYPE = "memeloop-rpc-response-v1";
+var LIBP2P_RPC_REQUEST_TYPE = "memeloop-rpc-request-v2";
+var LIBP2P_RPC_RESPONSE_TYPE = "memeloop-rpc-response-v2";
 function isLibp2pRpcRequest(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
   const record = value;
@@ -404,7 +899,7 @@ function isLibp2pRpcResponse(value) {
 }
 
 // src/device-network/localTrustDeviceAuthorizer.ts
-var PAIRING_PROTOCOL = "/memeloop/pairing/1.0.0";
+var PAIRING_PROTOCOL = "/memeloop/pairing/2.0.0";
 var LocalTrustDeviceAuthorizer = class {
   constructor(options = {}) {
     this.options = options;
@@ -430,7 +925,7 @@ var LocalTrustDeviceAuthorizer = class {
 };
 
 // src/device-network/pairingInvite.ts
-var DEVICE_PAIRING_INVITE_PROTOCOL = "memeloop-device-pairing-v1";
+var DEVICE_PAIRING_INVITE_PROTOCOL = "memeloop-device-pairing-v2";
 var DEVICE_PAIRING_INVITE_TTL_MS = 5 * 6e4;
 var MAX_INVITE_LENGTH = 16 * 1024;
 var MAX_ADDRESSES = 8;
@@ -441,37 +936,82 @@ function requireText(value, name, maxLength) {
   }
   return trimmed;
 }
-function validateAddresses(addresses) {
+function finalPeerId(address) {
+  const parts = address.split("/");
+  for (let index = parts.length - 2; index >= 0; index -= 1) {
+    if (parts[index] === "p2p") return parts[index + 1];
+  }
+  return void 0;
+}
+function validateAddresses(addresses, peerId) {
   const unique = [...new Set(addresses.map((address) => address.trim()))].filter(Boolean);
   if (unique.length === 0 || unique.length > MAX_ADDRESSES || unique.some(
-    (address) => address.length > 2048 || !address.startsWith("/") || !address.includes("/ws") && !address.includes("/wss")
+    (address) => address.length > 2048 || !address.startsWith("/") || !address.includes("/ws") && !address.includes("/wss") || finalPeerId(address) !== peerId
   )) {
-    throw new Error("device pairing invite requires WebSocket multiaddrs");
+    throw new Error("device pairing invite requires PeerId-bound WebSocket multiaddrs");
   }
   return unique;
 }
-function createDevicePairingInvite(device, options = {}) {
+function validateLifetime(createdAt, expiresAt, now) {
+  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(expiresAt) || expiresAt <= createdAt || expiresAt - createdAt > DEVICE_PAIRING_INVITE_TTL_MS) {
+    throw new Error("invalid device pairing invite lifetime");
+  }
+  if (expiresAt <= now) throw new Error("device pairing invite has expired");
+}
+function unsignedPayload(invite) {
+  const peerId = requireText(invite.peerId, "peerId", 256);
+  return {
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    peerId,
+    publicKeyMultibase: requireText(invite.publicKeyMultibase, "publicKeyMultibase", 4096),
+    deviceName: requireText(invite.deviceName, "deviceName", 256),
+    multiaddrs: [...validateAddresses(invite.multiaddrs, peerId)].sort(),
+    createdAt: invite.createdAt,
+    expiresAt: invite.expiresAt
+  };
+}
+function canonicalDevicePairingInviteBytes(invite) {
+  const payload = unsignedPayload(invite);
+  const canonical = [
+    DEVICE_PAIRING_INVITE_PROTOCOL,
+    `peerId=${payload.peerId}`,
+    `publicKey=${payload.publicKeyMultibase}`,
+    `deviceName=${payload.deviceName}`,
+    `multiaddrs=${payload.multiaddrs.join(",")}`,
+    `createdAt=${payload.createdAt}`,
+    `expiresAt=${payload.expiresAt}`
+  ].join("\n");
+  return new TextEncoder().encode(canonical);
+}
+async function createDevicePairingInvite(device, options) {
   const createdAt = options.now ?? Date.now();
   const ttlMs = options.ttlMs ?? DEVICE_PAIRING_INVITE_TTL_MS;
-  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > DEVICE_PAIRING_INVITE_TTL_MS) {
+  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(ttlMs) || ttlMs <= 0) {
     throw new Error("invalid device pairing invite lifetime");
   }
-  return {
+  const payload = unsignedPayload({
     protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
-    peerId: requireText(device.peerId, "peerId", 256),
-    deviceName: requireText(device.displayName, "deviceName", 256),
-    multiaddrs: validateAddresses(device.multiaddrs ?? []),
+    peerId: device.peerId,
+    publicKeyMultibase: device.publicKeyMultibase,
+    deviceName: device.displayName,
+    multiaddrs: device.multiaddrs ?? [],
     createdAt,
     expiresAt: createdAt + ttlMs
-  };
+  });
+  validateLifetime(payload.createdAt, payload.expiresAt, createdAt - 1);
+  const signature = requireText(
+    await options.sign(canonicalDevicePairingInviteBytes(payload)),
+    "signature",
+    4096
+  );
+  return { ...payload, signature };
 }
 function encodeDevicePairingInvite(invite) {
-  const validated = parseDevicePairingInvite(JSON.stringify(invite), {
-    now: invite.createdAt
-  });
-  return JSON.stringify(validated);
+  const payload = unsignedPayload(invite);
+  const signature = requireText(invite.signature, "signature", 4096);
+  return JSON.stringify({ ...payload, signature });
 }
-function parseDevicePairingInvite(serialized, options = {}) {
+async function parseDevicePairingInvite(serialized, options) {
   if (!serialized || serialized.length > MAX_INVITE_LENGTH) {
     throw new Error("invalid device pairing invite length");
   }
@@ -485,20 +1025,30 @@ function parseDevicePairingInvite(serialized, options = {}) {
     throw new Error("invalid device pairing invite");
   }
   const record = parsed;
-  if (record.protocol !== DEVICE_PAIRING_INVITE_PROTOCOL || typeof record.peerId !== "string" || typeof record.deviceName !== "string" || !Array.isArray(record.multiaddrs) || record.multiaddrs.some((address) => typeof address !== "string") || typeof record.createdAt !== "number" || typeof record.expiresAt !== "number" || !Number.isSafeInteger(record.createdAt) || !Number.isSafeInteger(record.expiresAt) || record.expiresAt <= record.createdAt || record.expiresAt - record.createdAt > DEVICE_PAIRING_INVITE_TTL_MS) {
+  if (record.protocol !== DEVICE_PAIRING_INVITE_PROTOCOL || typeof record.peerId !== "string" || typeof record.publicKeyMultibase !== "string" || typeof record.deviceName !== "string" || !Array.isArray(record.multiaddrs) || record.multiaddrs.some((address) => typeof address !== "string") || typeof record.createdAt !== "number" || typeof record.expiresAt !== "number" || typeof record.signature !== "string") {
     throw new Error("invalid device pairing invite");
   }
-  if (record.expiresAt <= (options.now ?? Date.now())) {
-    throw new Error("device pairing invite has expired");
-  }
-  return {
+  validateLifetime(record.createdAt, record.expiresAt, options.now ?? Date.now());
+  const payload = unsignedPayload({
     protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
-    peerId: requireText(record.peerId, "peerId", 256),
-    deviceName: requireText(record.deviceName, "deviceName", 256),
-    multiaddrs: validateAddresses(record.multiaddrs),
+    peerId: record.peerId,
+    publicKeyMultibase: record.publicKeyMultibase,
+    deviceName: record.deviceName,
+    multiaddrs: record.multiaddrs,
     createdAt: record.createdAt,
     expiresAt: record.expiresAt
+  });
+  const invite = {
+    ...payload,
+    signature: requireText(record.signature, "signature", 4096)
   };
+  if (!await options.verifyIdentity({
+    invite,
+    payload: canonicalDevicePairingInviteBytes(payload)
+  })) {
+    throw new Error("device pairing invite identity verification failed");
+  }
+  return invite;
 }
 
 // src/sync/attachmentRpcCodec.ts
@@ -527,43 +1077,66 @@ var ChatSyncEngine = class {
   nodeId;
   storage;
   getPeers;
+  stateStore;
   versionVector = {};
+  loadStatePromise;
+  stateMutation = Promise.resolve();
   constructor(options) {
     this.nodeId = options.nodeId;
     this.storage = options.storage;
     this.getPeers = options.peers;
-    this.versionVector[this.nodeId] = 0;
+    this.stateStore = options.stateStore ?? new MemoryDeviceSyncStateStore();
   }
   /**
    * 在本节点新产生一条消息时调用，增加本节点的 lamportClock。
    */
   bumpLocalVersion() {
-    this.versionVector[this.nodeId] = (this.versionVector[this.nodeId] ?? 0) + 1;
+    let nextClock = 0;
+    const mutation = this.stateMutation.then(async () => {
+      await this.ensureStateLoaded();
+      nextClock = (this.versionVector[this.nodeId] ?? 0) + 1;
+      this.versionVector[this.nodeId] = nextClock;
+      await this.stateStore.saveVersionVector(this.versionVector);
+    });
+    this.stateMutation = mutation.catch(() => void 0);
+    return mutation.then(() => nextClock);
   }
   /**
    * 执行一次与所有 peer 的增量同步（metadata 级别），并尽力拉取缺失消息。
    */
   async syncOnce() {
+    await this.ensureStateLoaded();
+    await this.stateMutation;
+    await this.reconcileVersionVectorFromStorage();
     const peers = this.getPeers();
     if (peers.length === 0) return;
-    const localVersion = { ...this.versionVector };
     const pulledConversations = /* @__PURE__ */ new Set();
     for (const peer of peers) {
-      const { remoteVersion, missingForRemote } = await peer.exchangeVersionVector(localVersion);
-      const missingForLocal = await peer.pullMissingMetadata(this.versionVector);
-      for (const meta of missingForLocal) {
-        await this.storage.upsertConversationMetadata(meta);
-        pulledConversations.add(meta.conversationId);
-      }
+      const { remoteVersion } = await peer.exchangeVersionVector({ ...this.versionVector });
+      let cursor;
+      do {
+        const page = await peer.pullMissingMetadata(this.versionVector, cursor);
+        for (const meta of page.items) {
+          await this.storage.upsertConversationMetadata(meta);
+          pulledConversations.add(meta.conversationId);
+        }
+        cursor = page.nextCursor;
+      } while (cursor !== void 0);
       for (const [nodeId, clock] of Object.entries(remoteVersion)) {
         const current = this.versionVector[nodeId] ?? 0;
-        if (clock > current) {
-          this.versionVector[nodeId] = clock;
-        }
+        if (clock > current) this.versionVector[nodeId] = clock;
       }
-      if (missingForRemote.length > 0) {
-        this.bumpLocalVersion();
+      await this.stateStore.saveVersionVector(this.versionVector);
+    }
+    const pageSize = 100;
+    let offset = 0;
+    for (; ; ) {
+      const conversations = await this.storage.listConversations({ limit: pageSize, offset });
+      for (const conversation of conversations) {
+        pulledConversations.add(conversation.conversationId);
       }
+      if (conversations.length < pageSize) break;
+      offset += conversations.length;
     }
     for (const conversationId of pulledConversations) {
       await this.pullMessagesForConversationFromPeers(conversationId, peers);
@@ -574,11 +1147,6 @@ var ChatSyncEngine = class {
    */
   async antiEntropyOnce() {
     await this.syncOnce();
-    const list = await this.storage.listConversations({ limit: 500 });
-    const peers = this.getPeers();
-    for (const meta of list) {
-      await this.pullMessagesForConversationFromPeers(meta.conversationId, peers);
-    }
   }
   async pullMessagesForConversationFromPeers(conversationId, peers) {
     const localMsgs = await this.storage.getMessages(conversationId, { mode: "full-content" });
@@ -631,12 +1199,39 @@ var ChatSyncEngine = class {
       }
     }
   }
-  getVersionVector() {
+  async getVersionVector() {
+    await this.ensureStateLoaded();
+    await this.stateMutation;
     return { ...this.versionVector };
   }
   getStorage() {
     return this.storage;
   }
+  ensureStateLoaded() {
+    this.loadStatePromise ??= (async () => {
+      const stored = await this.stateStore.loadVersionVector();
+      this.versionVector = { ...stored, [this.nodeId]: stored[this.nodeId] ?? 0 };
+    })();
+    return this.loadStatePromise;
+  }
+  async reconcileVersionVectorFromStorage() {
+    const pageSize = 100;
+    let offset = 0;
+    let changed = false;
+    for (; ; ) {
+      const conversations = await this.storage.listConversations({ limit: pageSize, offset });
+      for (const conversation of conversations) {
+        const current = this.versionVector[conversation.originNodeId] ?? 0;
+        if (conversation.originClock > current) {
+          this.versionVector[conversation.originNodeId] = conversation.originClock;
+          changed = true;
+        }
+      }
+      if (conversations.length < pageSize) break;
+      offset += conversations.length;
+    }
+    if (changed) await this.stateStore.saveVersionVector(this.versionVector);
+  }
 };
 
 // src/sync/peerNodeAdapter.ts
@@ -650,8 +1245,8 @@ var PeerNodeSyncAdapter = class {
   exchangeVersionVector(localVersion) {
     return this.transport.exchangeVersionVector(this.nodeId, localVersion);
   }
-  pullMissingMetadata(sinceVersion) {
-    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion);
+  pullMissingMetadata(sinceVersion, cursor) {
+    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion, cursor);
   }
   pullMissingMessages(conversationId, knownMessageIds) {
     const function_ = this.transport.pullMissingMessages?.bind(this.transport);
@@ -673,7 +1268,17 @@ var PeerNodeSyncAdapter = class {
 function isConversationMeta(value) {
   if (value === null || typeof value !== "object") return false;
   const o = value;
-  return typeof o.conversationId === "string" && typeof o.title === "string" && typeof o.originNodeId === "string" && typeof o.definitionId === "string" && typeof o.messageCount === "number" && typeof o.lastMessageTimestamp === "number" && typeof o.isUserInitiated === "boolean";
+  return typeof o.conversationId === "string" && typeof o.title === "string" && typeof o.originNodeId === "string" && typeof o.originClock === "number" && typeof o.definitionId === "string" && typeof o.messageCount === "number" && typeof o.lastMessageTimestamp === "number" && typeof o.isUserInitiated === "boolean";
+}
+function computeMissingVersionRanges(currentVersion, availableVersion) {
+  const ranges = [];
+  for (const [originNodeId, availableClock] of Object.entries(availableVersion)) {
+    const currentClock = currentVersion[originNodeId] ?? 0;
+    if (availableClock > currentClock) {
+      ranges.push({ originNodeId, fromExclusive: currentClock, toInclusive: availableClock });
+    }
+  }
+  return ranges.sort((left, right) => left.originNodeId.localeCompare(right.originNodeId));
 }
 
 // src/device-network/memoryDeviceNetworkService.ts
@@ -813,6 +1418,8 @@ var MemoryDeviceNetworkService = class {
       async sink() {
       },
       async close() {
+      },
+      abort() {
       }
     };
   }
@@ -847,11 +1454,21 @@ var MemoryDeviceNetworkService = class {
 // src/device-network/syncCloudDevices.ts
 async function syncCloudDevices(input) {
   const cloudDevices = await input.cloudClient.listDevices();
-  if (cloudDevices.length === 0) return [];
   const existingRecords = await input.trustStore.loadTrustedDevices();
   const existingByPeerId = new Map(existingRecords.map((r) => [r.peerId, r]));
-  for (const cloudDevice of cloudDevices) {
+  const excludedPeerIds = new Set(input.excludePeerIds ?? []);
+  const activeCloudDevices = cloudDevices.filter(
+    (device) => device.revokedAt === void 0 && !excludedPeerIds.has(device.peerId)
+  );
+  const visibleCloudPeerIds = new Set(activeCloudDevices.map((device) => device.peerId));
+  for (const existing of existingRecords) {
+    if (existing.trustMode === "cloud-account" && !visibleCloudPeerIds.has(existing.peerId)) {
+      await input.trustStore.removeTrustedDevice(existing.peerId);
+    }
+  }
+  for (const cloudDevice of activeCloudDevices) {
     const existing = existingByPeerId.get(cloudDevice.peerId);
+    if (existing?.trustMode === "local-pairing") continue;
     const record = {
       peerId: cloudDevice.peerId,
       publicKeyMultibase: cloudDevice.publicKeyMultibase,
@@ -863,17 +1480,14 @@ async function syncCloudDevices(input) {
       lastSeen: cloudDevice.lastSeen,
       revokedAt: cloudDevice.revokedAt
     };
-    if (existing) {
-      existing.lastSeen = cloudDevice.lastSeen;
-      existing.revokedAt = cloudDevice.revokedAt;
-      if (existing.publicKeyMultibase !== record.publicKeyMultibase || existing.deviceName !== record.deviceName || existing.platform !== record.platform) {
-        await input.trustStore.saveTrustedDevice(record);
-      }
-    } else {
+    if (!existing || !sameTrustedDevice(existing, record)) {
       await input.trustStore.saveTrustedDevice(record);
     }
   }
-  return cloudDevices;
+  return activeCloudDevices;
+}
+function sameTrustedDevice(left, right) {
+  return left.peerId === right.peerId && left.publicKeyMultibase === right.publicKeyMultibase && left.deviceName === right.deviceName && left.platform === right.platform && left.trustMode === right.trustMode && left.accountId === right.accountId && left.createdAt === right.createdAt && left.lastSeen === right.lastSeen && left.revokedAt === right.revokedAt;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -881,6 +1495,8 @@ async function syncCloudDevices(input) {
   DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_PROTOCOL,
   DEVICE_PAIRING_INVITE_TTL_MS,
+  DeviceCloudConnectionCoordinator,
+  JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE,
   LIBP2P_RPC_RESPONSE_TYPE,
   LIBP2P_SYNC_REQUEST_TYPE,
@@ -888,13 +1504,19 @@ async function syncCloudDevices(input) {
   Libp2pDeviceSyncTransport,
   LocalTrustDeviceAuthorizer,
   MemoryDeviceNetworkService,
+  MemoryDeviceSyncStateStore,
   PeerNodeSyncAdapter,
   attachmentBlobFromWire,
+  canonicalDevicePairingInviteBytes,
+  computeMissingVersionRanges,
   createDeviceOrchestrationStreamHandler,
   createDeviceOrchestrationTransport,
   createDevicePairingInvite,
+  createJsonFrameReader,
   decodeAttachmentBlobRpc,
   encodeDevicePairingInvite,
+  encodeJsonFrame,
+  encodeJsonFrames,
   isConversationMeta,
   isLibp2pRpcRequest,
   isLibp2pRpcResponse,