memeloop 0.1.3 → 0.2.0

package/dist/chunk-ECNKBH5A.js

@@ -0,0 +1,1235 @@
+import {
+  OrchestrationError
+} from "./chunk-FWSY5HOA.js";
+
+// src/sync/attachmentRpcCodec.ts
+function decodeAttachmentBlobRpc(result) {
+  if (result == null || typeof result !== "object") return null;
+  const r = result;
+  if (r.error || !r.found || typeof r.dataBase64 !== "string") return null;
+  let data;
+  try {
+    const binary = atob(r.dataBase64);
+    if (!binary.length) return null;
+    data = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  } catch {
+    return null;
+  }
+  return {
+    data,
+    filename: typeof r.filename === "string" ? r.filename : "attachment",
+    mimeType: typeof r.mimeType === "string" ? r.mimeType : "application/octet-stream",
+    size: typeof r.size === "number" && r.size > 0 ? r.size : data.byteLength
+  };
+}
+
+// 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/sync/chatSyncEngine.ts
+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.stateStore = options.stateStore ?? new MemoryDeviceSyncStateStore();
+  }
+  /**
+   * 在本节点新产生一条消息时调用，增加本节点的 lamportClock。
+   */
+  bumpLocalVersion() {
+    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 pulledConversations = /* @__PURE__ */ new Set();
+    for (const peer of peers) {
+      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;
+      }
+      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);
+    }
+  }
+  /**
+   * Anti-entropy：先 syncOnce，再对已知会话逐个向各 peer 拉取缺失消息（参考审查单「定期对账」）。
+   */
+  async antiEntropyOnce() {
+    await this.syncOnce();
+  }
+  async pullMessagesForConversationFromPeers(conversationId, peers) {
+    const localMsgs = await this.storage.getMessages(conversationId, { mode: "full-content" });
+    const knownIds = localMsgs.map((m) => m.messageId);
+    for (const peer of peers) {
+      if (!peer.pullMissingMessages) continue;
+      try {
+        const incoming = await peer.pullMissingMessages(conversationId, knownIds);
+        if (incoming.length > 0) {
+          await this.storage.insertMessagesIfAbsent(incoming);
+          await this.ensureAttachmentsFromMessages(incoming, peers);
+        }
+      } catch {
+      }
+    }
+  }
+  /** 从消息元数据收集 `attachments[].contentHash`，对本地缺失 BLOB 的哈希向各 peer 拉取并 `saveAttachment`。 */
+  async ensureAttachmentsFromMessages(messages, peers) {
+    const hashes = /* @__PURE__ */ new Set();
+    for (const m of messages) {
+      for (const a of m.attachments ?? []) {
+        if (a.contentHash) hashes.add(a.contentHash);
+      }
+    }
+    for (const h of hashes) {
+      const reference = await this.storage.getAttachment(h);
+      if (reference) {
+        const reader = this.storage.readAttachmentData?.bind(this.storage);
+        if (!reader) continue;
+        const bytes = await reader(h);
+        if (bytes && bytes.length > 0) continue;
+      }
+      for (const peer of peers) {
+        const pull = peer.pullAttachmentBlob?.bind(peer);
+        if (!pull) continue;
+        try {
+          const blob = await pull(h);
+          if (blob?.data?.length) {
+            const ar = {
+              contentHash: h,
+              filename: blob.filename,
+              mimeType: blob.mimeType,
+              size: blob.size > 0 ? blob.size : blob.data.length
+            };
+            await this.storage.saveAttachment(ar, blob.data);
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  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
+var PeerNodeSyncAdapter = class {
+  nodeId;
+  transport;
+  constructor(nodeId, transport) {
+    this.nodeId = nodeId;
+    this.transport = transport;
+  }
+  exchangeVersionVector(localVersion) {
+    return this.transport.exchangeVersionVector(this.nodeId, localVersion);
+  }
+  pullMissingMetadata(sinceVersion, cursor) {
+    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion, cursor);
+  }
+  pullMissingMessages(conversationId, knownMessageIds) {
+    const function_ = this.transport.pullMissingMessages?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve([]);
+    }
+    return function_(this.nodeId, conversationId, knownMessageIds);
+  }
+  pullAttachmentBlob(contentHash) {
+    const function_ = this.transport.pullAttachmentBlob?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve(null);
+    }
+    return function_(this.nodeId, contentHash);
+  }
+};
+
+// 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/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/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,
+    message,
+    retryable: code === "UNAVAILABLE"
+  });
+}
+function assertFrameLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < 256) {
+    throw new TypeError("maxFrameBytes must be a safe integer of at least 256");
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw orchestrationTransportError("CANCELLED", "device orchestration request was cancelled");
+  }
+}
+async function openAuthenticatedStream(options) {
+  const grant = await options.grantProvider?.(options.peerId);
+  return {
+    stream: await options.deviceNetwork.openStream(
+      options.peerId,
+      DEVICE_ORCHESTRATION_PROTOCOL,
+      grant
+    ),
+    grant
+  };
+}
+async function writeRequest(stream, request, grant, maxFrameBytes) {
+  const envelope = {
+    type: "memeloop-device-orchestration-request-v2",
+    request,
+    ...grant ? { grant } : {}
+  };
+  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;
+  assertFrameLimit(maxFrameBytes);
+  return {
+    async request(request, transportOptions = {}) {
+      throwIfAborted(transportOptions.signal);
+      const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
+      const closeOnAbort = () => {
+        void abort(orchestrationTransportError("CANCELLED", "device orchestration request was cancelled"));
+      };
+      transportOptions.signal?.addEventListener("abort", closeOnAbort, {
+        once: true
+      });
+      try {
+        await writeRequest(stream, request, grant, maxFrameBytes);
+        let response;
+        for await (const value of frameReader(
+          stream,
+          maxFrameBytes,
+          REQUEST_IDLE_TIMEOUT_MS,
+          transportOptions.signal,
+          abort
+        )) {
+          if (response) {
+            throw orchestrationTransportError(
+              "INVALID",
+              "device orchestration request returned multiple responses"
+            );
+          }
+          response = value;
+        }
+        throwIfAborted(transportOptions.signal);
+        if (!response) {
+          throw orchestrationTransportError(
+            "UNAVAILABLE",
+            "device orchestration request returned no response"
+          );
+        }
+        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);
+      }
+    },
+    async *watch(request, transportOptions = {}) {
+      throwIfAborted(transportOptions.signal);
+      const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
+      const closeOnAbort = () => {
+        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 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);
+      }
+    }
+  };
+}
+async function readSingleRequest(stream, maxFrameBytes) {
+  const abort = abortStreamOnce(stream);
+  let envelope;
+  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-v2" || value.request === null || typeof value.request !== "object") {
+      throw orchestrationTransportError(
+        "INVALID",
+        "device orchestration request envelope is invalid"
+      );
+    }
+    envelope = value;
+  }
+  if (!envelope) {
+    throw orchestrationTransportError("INVALID", "device orchestration request is missing");
+  }
+  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);
+  return async ({ remotePeerId, stream, authorize }) => {
+    const abort = new AbortController();
+    try {
+      const envelope = await readSingleRequest(stream, maxFrameBytes);
+      if (authorize && !await authorize(envelope.grant)) {
+        throw orchestrationTransportError("UNAVAILABLE", "device_not_trusted");
+      }
+      const request = envelope.request;
+      const handler = await options.resolveHandler(remotePeerId);
+      if (request.operation === "watch") {
+        await stream.sink(
+          encodeJsonFrames(
+            withWatchBookmarks(handler.watch(request, { signal: abort.signal }), request, abort.signal),
+            maxFrameBytes
+          )
+        );
+      } else {
+        await stream.sink(encodeJsonFrames([await handler.request(request)], maxFrameBytes));
+      }
+    } finally {
+      abort.abort();
+      await stream.close().catch(() => void 0);
+    }
+  };
+}
+
+// src/device-network/libp2pSyncProtocol.ts
+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",
+  "pullMissingMessages",
+  "pullAttachmentBlob"
+]);
+function isLibp2pSyncRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === LIBP2P_SYNC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string" && syncMethods.has(record.method);
+}
+function isLibp2pSyncResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_SYNC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+function isAttachmentBlobWire(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.dataBase64Url === "string" && typeof record.filename === "string" && typeof record.mimeType === "string" && typeof record.size === "number";
+}
+async function attachmentBlobFromWire(value) {
+  if (value === null) return null;
+  if (!isAttachmentBlobWire(value)) throw new Error("invalid_sync_response");
+  let data;
+  try {
+    const base64 = value.dataBase64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const paddedBase64 = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+    const binary = atob(paddedBase64);
+    data = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  } catch {
+    throw new Error("invalid_sync_response");
+  }
+  return {
+    data,
+    filename: value.filename,
+    mimeType: value.mimeType,
+    size: value.size
+  };
+}
+
+// src/device-network/libp2pDeviceSyncTransport.ts
+var Libp2pDeviceSyncTransport = class {
+  nodeId;
+  deviceNetwork;
+  grantProvider;
+  constructor(options) {
+    this.nodeId = options.nodeId;
+    this.deviceNetwork = options.deviceNetwork;
+    this.grantProvider = options.grantProvider;
+  }
+  listPeers() {
+    return this.deviceNetwork.listDevices();
+  }
+  exchangeVersionVector(peerId, localVersion) {
+    return this.request(peerId, "exchangeVersionVector", { localVersion });
+  }
+  pullMissingMetadata(peerId, sinceVersion, cursor) {
+    return this.request(peerId, "pullMissingMetadata", {
+      sinceVersion,
+      cursor
+    });
+  }
+  pullMissingMessages(peerId, conversationId, knownMessageIds) {
+    return this.request(peerId, "pullMissingMessages", { conversationId, knownMessageIds });
+  }
+  async pullAttachmentBlob(peerId, contentHash) {
+    const result = await this.request(peerId, "pullAttachmentBlob", { contentHash });
+    return attachmentBlobFromWire(result);
+  }
+  async request(peerId, method, parameters) {
+    const grant = await this.grantProvider?.(peerId);
+    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/2.0.0", grant);
+    const request = {
+      type: LIBP2P_SYNC_REQUEST_TYPE,
+      id: crypto.randomUUID(),
+      method,
+      params: parameters,
+      grant
+    };
+    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);
+    }
+  }
+};
+
+// src/device-network/libp2pRpcProtocol.ts
+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;
+  return record.type === LIBP2P_RPC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string";
+}
+function isLibp2pRpcResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_RPC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+
+// src/device-network/localTrustDeviceAuthorizer.ts
+var PAIRING_PROTOCOL = "/memeloop/pairing/2.0.0";
+var LocalTrustDeviceAuthorizer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.allowPairingProtocol = options.allowPairingProtocol ?? true;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  trustedDevices = /* @__PURE__ */ new Map();
+  allowPairingProtocol;
+  setTrustedDevice(record) {
+    this.trustedDevices.set(record.peerId, record);
+  }
+  removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+  }
+  async canOpenProtocol(input) {
+    const record = this.options.getTrustedDevice?.(input.remotePeerId) ?? this.trustedDevices.get(input.remotePeerId);
+    if (record?.revokedAt) return false;
+    if (input.protocol === PAIRING_PROTOCOL) return this.allowPairingProtocol;
+    return record !== void 0;
+  }
+};
+
+// src/device-network/pairingInvite.ts
+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;
+function requireText(value, name, maxLength) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maxLength) {
+    throw new Error(`invalid device pairing invite ${name}`);
+  }
+  return trimmed;
+}
+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") || finalPeerId(address) !== peerId
+  )) {
+    throw new Error("device pairing invite requires PeerId-bound WebSocket multiaddrs");
+  }
+  return unique;
+}
+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) {
+    throw new Error("invalid device pairing invite lifetime");
+  }
+  const payload = unsignedPayload({
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    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 payload = unsignedPayload(invite);
+  const signature = requireText(invite.signature, "signature", 4096);
+  return JSON.stringify({ ...payload, signature });
+}
+async function parseDevicePairingInvite(serialized, options) {
+  if (!serialized || serialized.length > MAX_INVITE_LENGTH) {
+    throw new Error("invalid device pairing invite length");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("device pairing invite is not valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("invalid device pairing invite");
+  }
+  const record = parsed;
+  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");
+  }
+  validateLifetime(record.createdAt, record.expiresAt, options.now ?? Date.now());
+  const payload = unsignedPayload({
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    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/protocol.ts
+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.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));
+}
+
+export {
+  decodeAttachmentBlobRpc,
+  MemoryDeviceSyncStateStore,
+  ChatSyncEngine,
+  PeerNodeSyncAdapter,
+  DeviceCloudConnectionCoordinator,
+  JsonFrameError,
+  encodeJsonFrame,
+  encodeJsonFrames,
+  createJsonFrameReader,
+  DEVICE_ORCHESTRATION_PROTOCOL,
+  createDeviceOrchestrationTransport,
+  createDeviceOrchestrationStreamHandler,
+  LIBP2P_SYNC_REQUEST_TYPE,
+  LIBP2P_SYNC_RESPONSE_TYPE,
+  isLibp2pSyncRequest,
+  isLibp2pSyncResponse,
+  attachmentBlobFromWire,
+  Libp2pDeviceSyncTransport,
+  LIBP2P_RPC_REQUEST_TYPE,
+  LIBP2P_RPC_RESPONSE_TYPE,
+  isLibp2pRpcRequest,
+  isLibp2pRpcResponse,
+  LocalTrustDeviceAuthorizer,
+  DEVICE_PAIRING_INVITE_PROTOCOL,
+  DEVICE_PAIRING_INVITE_TTL_MS,
+  canonicalDevicePairingInviteBytes,
+  createDevicePairingInvite,
+  encodeDevicePairingInvite,
+  parseDevicePairingInvite,
+  isConversationMeta,
+  computeMissingVersionRanges
+};
+//# sourceMappingURL=chunk-ECNKBH5A.js.map