@prismer/sdk 1.8.1 → 1.8.2

package/dist/chunk-BWZXMXL7.mjs

@@ -0,0 +1,4762 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/realtime.ts
+var TypedEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, cb) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(cb);
+    return this;
+  }
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+    return this;
+  }
+  once(event, cb) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      cb(payload);
+    };
+    return this.on(event, wrapper);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (set) {
+      for (const cb of set) {
+        try {
+          cb(payload);
+        } catch (_) {
+        }
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+var Reconnector = class {
+  constructor(config) {
+    this.attempt = 0;
+    this.connectedAt = 0;
+    this.baseDelay = config.reconnectBaseDelay ?? 1e3;
+    this.maxDelay = config.reconnectMaxDelay ?? 3e4;
+    this.maxAttempts = config.maxReconnectAttempts ?? 10;
+  }
+  get shouldReconnect() {
+    return this.maxAttempts === 0 || this.attempt < this.maxAttempts;
+  }
+  get currentAttempt() {
+    return this.attempt;
+  }
+  markConnected() {
+    this.connectedAt = Date.now();
+  }
+  nextDelay() {
+    if (this.connectedAt > 0 && Date.now() - this.connectedAt > 6e4) {
+      this.attempt = 0;
+    }
+    const jitter = Math.random() * this.baseDelay * 0.5;
+    const delay = Math.min(this.baseDelay * Math.pow(2, this.attempt) + jitter, this.maxDelay);
+    this.attempt++;
+    return delay;
+  }
+  reset() {
+    this.attempt = 0;
+    this.connectedAt = 0;
+  }
+};
+var RealtimeWSClient = class extends TypedEmitter {
+  constructor(baseUrl, config) {
+    super();
+    this.ws = null;
+    this.heartbeatTimer = null;
+    this.pongTimer = null;
+    this.reconnectTimer = null;
+    this.pendingPings = /* @__PURE__ */ new Map();
+    this._state = "disconnected";
+    this.intentionalClose = false;
+    this.pingCounter = 0;
+    this.handleMessage = (ev) => {
+      try {
+        const msg = JSON.parse(typeof ev.data === "string" ? ev.data : ev.data.toString());
+        const { type, payload } = msg;
+        if (type === "pong" && payload?.requestId) {
+          const pending = this.pendingPings.get(payload.requestId);
+          if (pending) {
+            clearTimeout(pending.timer);
+            pending.resolve(payload);
+            this.pendingPings.delete(payload.requestId);
+          }
+        }
+        this.emit(type, payload);
+      } catch (_) {
+      }
+    };
+    this.handleClose = (ev) => {
+      this.stopHeartbeat();
+      this.clearPendingPings();
+      this.ws = null;
+      if (this.intentionalClose) return;
+      this._state = "disconnected";
+      this.emit("disconnected", { code: ev.code, reason: ev.reason });
+      if (this.config.autoReconnect && this.reconnector.shouldReconnect) {
+        this.scheduleReconnect();
+      }
+    };
+    const base = baseUrl.replace(/^http/, "ws");
+    this.wsUrl = `${base}/ws?token=${config.token}`;
+    this.config = {
+      autoReconnect: true,
+      heartbeatInterval: 25e3,
+      ...config
+    };
+    this.reconnector = new Reconnector(config);
+    this.WS = config.WebSocket || WebSocket;
+  }
+  get state() {
+    return this._state;
+  }
+  async connect() {
+    if (this._state === "connected" || this._state === "connecting") return;
+    this._state = "connecting";
+    this.intentionalClose = false;
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new this.WS(this.wsUrl);
+      } catch (err) {
+        this._state = "disconnected";
+        reject(err);
+        return;
+      }
+      const onOpen = () => {
+        cleanup();
+      };
+      const onFirstMessage = (ev) => {
+        try {
+          const msg = JSON.parse(typeof ev.data === "string" ? ev.data : ev.data.toString());
+          if (msg.type === "authenticated") {
+            this._state = "connected";
+            this.reconnector.markConnected();
+            this.startHeartbeat();
+            this.emit("authenticated", msg.payload);
+            this.emit("connected", void 0);
+            this.ws.removeEventListener("message", onFirstMessage);
+            this.ws.addEventListener("message", this.handleMessage);
+            resolve();
+          }
+        } catch (_) {
+        }
+      };
+      const onError = (ev) => {
+        cleanup();
+        if (this._state === "connecting") {
+          this._state = "disconnected";
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+      const onClose = (ev) => {
+        cleanup();
+        if (this._state === "connecting") {
+          this._state = "disconnected";
+          reject(new Error(`WebSocket closed during connect: ${ev.code} ${ev.reason}`));
+        }
+      };
+      const cleanup = () => {
+        this.ws?.removeEventListener("error", onError);
+        this.ws?.removeEventListener("close", onClose);
+      };
+      this.ws.addEventListener("open", onOpen);
+      this.ws.addEventListener("message", onFirstMessage);
+      this.ws.addEventListener("error", onError);
+      this.ws.addEventListener("close", onClose);
+      this.ws.addEventListener("close", this.handleClose);
+    });
+  }
+  disconnect(code = 1e3, reason = "client disconnect") {
+    this.intentionalClose = true;
+    this.stopHeartbeat();
+    this.clearReconnectTimer();
+    this.clearPendingPings();
+    if (this.ws) {
+      this.ws.removeEventListener("message", this.handleMessage);
+      this.ws.removeEventListener("close", this.handleClose);
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close(code, reason);
+      }
+      this.ws = null;
+    }
+    this._state = "disconnected";
+    this.emit("disconnected", { code, reason });
+  }
+  // --- Commands ---
+  joinConversation(conversationId) {
+    this.sendRaw({ type: "conversation.join", payload: { conversationId } });
+  }
+  sendMessage(conversationId, content, options) {
+    const opts = typeof options === "string" ? { type: options } : options;
+    this.sendRaw({
+      type: "message.send",
+      payload: { conversationId, content, type: opts?.type ?? "text", ...opts?.metadata ? { metadata: opts.metadata } : {}, ...opts?.parentId ? { parentId: opts.parentId } : {} },
+      requestId: `msg-${++this.pingCounter}`
+    });
+  }
+  startTyping(conversationId) {
+    this.sendRaw({ type: "typing.start", payload: { conversationId } });
+  }
+  stopTyping(conversationId) {
+    this.sendRaw({ type: "typing.stop", payload: { conversationId } });
+  }
+  updatePresence(status) {
+    this.sendRaw({ type: "presence.update", payload: { status } });
+  }
+  send(command) {
+    this.sendRaw(command);
+  }
+  ping() {
+    const requestId = `ping-${++this.pingCounter}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingPings.delete(requestId);
+        reject(new Error("Ping timeout"));
+      }, 1e4);
+      this.pendingPings.set(requestId, { resolve, timer });
+      this.sendRaw({ type: "ping", payload: { requestId } });
+    });
+  }
+  // --- Internal ---
+  sendRaw(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  scheduleReconnect() {
+    const delay = this.reconnector.nextDelay();
+    this._state = "reconnecting";
+    this.emit("reconnecting", { attempt: this.reconnector.currentAttempt, delayMs: delay });
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (_) {
+        if (this.config.autoReconnect && this.reconnector.shouldReconnect) {
+          this.scheduleReconnect();
+        } else {
+          this._state = "disconnected";
+        }
+      }
+    }, delay);
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this._state !== "connected") return;
+      const requestId = `hb-${++this.pingCounter}`;
+      this.sendRaw({ type: "ping", payload: { requestId } });
+      this.pongTimer = setTimeout(() => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close(4e3, "heartbeat timeout");
+        }
+      }, 1e4);
+      const onPong = (payload) => {
+        if (this.pongTimer) {
+          clearTimeout(this.pongTimer);
+          this.pongTimer = null;
+        }
+        this.off("pong", onPong);
+      };
+      this.on("pong", onPong);
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  clearPendingPings() {
+    for (const [, { timer }] of this.pendingPings) {
+      clearTimeout(timer);
+    }
+    this.pendingPings.clear();
+  }
+};
+var RealtimeSSEClient = class extends TypedEmitter {
+  constructor(baseUrl, config) {
+    super();
+    this.abortController = null;
+    this.reconnectTimer = null;
+    this.heartbeatWatchdog = null;
+    this.lastDataTime = 0;
+    this._state = "disconnected";
+    this.intentionalClose = false;
+    this.sseUrl = `${baseUrl}/sse?token=${config.token}`;
+    this.config = {
+      autoReconnect: true,
+      ...config
+    };
+    this.reconnector = new Reconnector(config);
+    this.fetchFn = config.fetch || fetch;
+  }
+  get state() {
+    return this._state;
+  }
+  async connect() {
+    if (this._state === "connected" || this._state === "connecting") return;
+    this._state = "connecting";
+    this.intentionalClose = false;
+    this.abortController = new AbortController();
+    const response = await this.fetchFn(this.sseUrl, {
+      headers: { "Accept": "text/event-stream" },
+      signal: this.abortController.signal
+    });
+    if (!response.ok) {
+      this._state = "disconnected";
+      throw new Error(`SSE connection failed: ${response.status}`);
+    }
+    if (!response.body) {
+      this._state = "disconnected";
+      throw new Error("SSE response has no body");
+    }
+    this._state = "connected";
+    this.reconnector.markConnected();
+    this.lastDataTime = Date.now();
+    this.startHeartbeatWatchdog();
+    this.emit("connected", void 0);
+    this.readStream(response.body);
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    this.stopHeartbeatWatchdog();
+    this.clearReconnectTimer();
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this._state = "disconnected";
+    this.emit("disconnected", { code: 1e3, reason: "client disconnect" });
+  }
+  // --- Internal ---
+  async readStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          this.lastDataTime = Date.now();
+          if (line.startsWith(":")) {
+            continue;
+          }
+          if (line.startsWith("data: ")) {
+            const jsonStr = line.slice(6);
+            try {
+              const msg = JSON.parse(jsonStr);
+              this.emit(msg.type, msg.payload);
+            } catch (_) {
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (this.intentionalClose) return;
+    } finally {
+      reader.releaseLock();
+    }
+    if (this.intentionalClose) return;
+    this._state = "disconnected";
+    this.stopHeartbeatWatchdog();
+    this.emit("disconnected", { code: 0, reason: "stream ended" });
+    if (this.config.autoReconnect && this.reconnector.shouldReconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    const delay = this.reconnector.nextDelay();
+    this._state = "reconnecting";
+    this.emit("reconnecting", { attempt: this.reconnector.currentAttempt, delayMs: delay });
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (_) {
+        if (this.config.autoReconnect && this.reconnector.shouldReconnect) {
+          this.scheduleReconnect();
+        } else {
+          this._state = "disconnected";
+        }
+      }
+    }, delay);
+  }
+  startHeartbeatWatchdog() {
+    this.stopHeartbeatWatchdog();
+    this.heartbeatWatchdog = setInterval(() => {
+      if (Date.now() - this.lastDataTime > 45e3) {
+        this.stopHeartbeatWatchdog();
+        if (this.abortController) {
+          this.abortController.abort();
+          this.abortController = null;
+        }
+      }
+    }, 15e3);
+  }
+  stopHeartbeatWatchdog() {
+    if (this.heartbeatWatchdog) {
+      clearInterval(this.heartbeatWatchdog);
+      this.heartbeatWatchdog = null;
+    }
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/offline.ts
+var OfflineEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, cb) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(cb);
+    return this;
+  }
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+    return this;
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (set) for (const cb of set) {
+      try {
+        cb(payload);
+      } catch {
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+var WRITE_PATTERNS = [
+  { method: "POST", pattern: /\/api\/im\/(messages|direct|groups)\//, opType: "message.send" },
+  { method: "PATCH", pattern: /\/api\/im\/messages\//, opType: "message.edit" },
+  { method: "DELETE", pattern: /\/api\/im\/messages\//, opType: "message.delete" },
+  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" },
+  // v1.8.0 Community — queued when offline-first IM is enabled
+  { method: "POST", pattern: /\/api\/im\/community\/posts$/, opType: "community_post" },
+  { method: "POST", pattern: /\/api\/im\/community\/posts\/[^/]+\/comments$/, opType: "community_comment" },
+  { method: "POST", pattern: /\/api\/im\/community\/vote$/, opType: "community_vote" }
+];
+function matchWriteOp(method, path) {
+  for (const { method: m, pattern, opType } of WRITE_PATTERNS) {
+    if (method === m && pattern.test(path)) return opType;
+  }
+  return null;
+}
+var OfflineManager = class extends OfflineEmitter {
+  constructor(storage, networkRequest, options = {}) {
+    super();
+    this.flushTimer = null;
+    this.flushing = false;
+    this._isOnline = true;
+    this._syncState = "idle";
+    this.sseSource = null;
+    this.sseReconnectTimer = null;
+    this.sseReconnectAttempts = 0;
+    /** Presence cache for realtime presence events */
+    this.presenceCache = /* @__PURE__ */ new Map();
+    this.storage = storage;
+    this.networkRequest = networkRequest;
+    this.options = {
+      syncOnConnect: options.syncOnConnect ?? true,
+      outboxRetryLimit: options.outboxRetryLimit ?? 5,
+      outboxFlushInterval: options.outboxFlushInterval ?? 1e3,
+      conflictStrategy: options.conflictStrategy ?? "server",
+      onConflict: options.onConflict,
+      syncMode: options.syncMode ?? "push",
+      quota: options.quota ? {
+        maxStorageBytes: options.quota.maxStorageBytes ?? 500 * 1024 * 1024,
+        warningThreshold: options.quota.warningThreshold ?? 0.9
+      } : void 0
+    };
+  }
+  get isOnline() {
+    return this._isOnline;
+  }
+  get syncState() {
+    return this._syncState;
+  }
+  async init() {
+    await this.storage.init();
+    this.startFlushTimer();
+  }
+  async destroy() {
+    this.stopFlushTimer();
+    this.stopContinuousSync();
+    this.removeAllListeners();
+  }
+  // ── Network state ─────────────────────────────────────────
+  setOnline(online) {
+    if (this._isOnline === online) return;
+    this._isOnline = online;
+    this.emit(online ? "network.online" : "network.offline", void 0);
+    if (online) {
+      this.flush();
+      if (this.options.syncOnConnect) {
+        if (this.options.syncMode === "push") {
+          this.startContinuousSync();
+        } else {
+          this.sync();
+        }
+      }
+    } else {
+      this.stopContinuousSync();
+    }
+  }
+  // ── Request dispatch ──────────────────────────────────────
+  /**
+   * Dispatch an IM request. Write ops go through outbox; reads check local cache.
+   */
+  async dispatch(method, path, body, query) {
+    const opType = matchWriteOp(method, path);
+    if (opType) {
+      return this.dispatchWrite(opType, method, path, body, query);
+    }
+    if (method === "GET") {
+      const cached = await this.readFromCache(path, query);
+      if (cached !== null) return cached;
+    }
+    try {
+      const result = await this.networkRequest(method, path, body, query);
+      if (method === "GET") this.cacheReadResult(path, query, result);
+      return result;
+    } catch {
+      if (!this._isOnline) {
+        return { ok: true, data: [] };
+      }
+      throw new Error("Network request failed");
+    }
+  }
+  // ── Outbox: write operations ──────────────────────────────
+  async dispatchWrite(opType, method, path, body, query) {
+    const clientId = generateId();
+    const idempotencyKey = `sdk-${clientId}`;
+    let enrichedBody = body;
+    if (body && typeof body === "object" && (opType === "message.send" || opType === "message.edit")) {
+      enrichedBody = { ...body };
+      enrichedBody.metadata = {
+        ...body.metadata,
+        _idempotencyKey: idempotencyKey
+      };
+    }
+    let localMessage;
+    if (opType === "message.send" && body && typeof body === "object") {
+      const b = body;
+      const convIdMatch = path.match(/\/(?:messages|direct|groups)\/([^/]+)/);
+      const conversationId = convIdMatch?.[1] ?? "";
+      localMessage = {
+        id: `local-${clientId}`,
+        clientId,
+        conversationId,
+        content: b.content ?? "",
+        type: b.type ?? "text",
+        senderId: "__self__",
+        parentId: b.parentId ?? null,
+        status: "pending",
+        metadata: b.metadata,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.storage.putMessages([localMessage]);
+      this.emit("message.local", localMessage);
+    }
+    const op = {
+      id: clientId,
+      type: opType,
+      method,
+      path,
+      body: enrichedBody,
+      query,
+      status: "pending",
+      createdAt: Date.now(),
+      retries: 0,
+      maxRetries: this.options.outboxRetryLimit,
+      idempotencyKey,
+      localData: localMessage
+    };
+    await this.storage.enqueue(op);
+    if (this._isOnline) this.flush();
+    const optimisticResult = {
+      ok: true,
+      data: localMessage ? { conversationId: localMessage.conversationId, message: localMessage } : void 0,
+      _pending: true,
+      _clientId: clientId
+    };
+    return optimisticResult;
+  }
+  // ── Outbox flush ──────────────────────────────────────────
+  startFlushTimer() {
+    this.stopFlushTimer();
+    this.flushTimer = setInterval(() => this.flush(), this.options.outboxFlushInterval);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  async flush() {
+    if (this.flushing || !this._isOnline) return;
+    this.flushing = true;
+    try {
+      const ops = await this.storage.dequeueReady(10);
+      for (const op of ops) {
+        this.emit("outbox.sending", { opId: op.id, type: op.type });
+        try {
+          const result = await this.networkRequest(
+            op.method,
+            op.path,
+            op.body,
+            op.query
+          );
+          if (result.ok) {
+            await this.storage.ack(op.id);
+            this.emit("outbox.confirmed", { opId: op.id, serverData: result.data });
+            if (op.type === "message.send" && op.localData) {
+              const local = op.localData;
+              const serverMsg = result.data?.message;
+              if (serverMsg) {
+                await this.storage.deleteMessage(local.id);
+                await this.storage.putMessages([{
+                  id: serverMsg.id,
+                  clientId: op.id,
+                  conversationId: serverMsg.conversationId ?? local.conversationId,
+                  content: serverMsg.content ?? local.content,
+                  type: serverMsg.type ?? local.type,
+                  senderId: serverMsg.senderId ?? local.senderId,
+                  parentId: serverMsg.parentId,
+                  status: "confirmed",
+                  metadata: serverMsg.metadata ? typeof serverMsg.metadata === "string" ? JSON.parse(serverMsg.metadata) : serverMsg.metadata : void 0,
+                  createdAt: serverMsg.createdAt ?? local.createdAt
+                }]);
+                this.emit("message.confirmed", { clientId: op.id, serverMessage: serverMsg });
+              }
+            }
+          } else {
+            const errCode = result.error?.code;
+            if (errCode && !errCode.includes("TIMEOUT") && !errCode.includes("NETWORK")) {
+              await this.storage.nack(op.id, result.error?.message ?? "Request failed", op.maxRetries);
+              this.emit("outbox.failed", { opId: op.id, error: result.error?.message ?? "Request failed", retriesLeft: 0 });
+              if (op.type === "message.send") {
+                this.emit("message.failed", { clientId: op.id, error: result.error?.message ?? "Request failed" });
+              }
+            } else {
+              await this.storage.nack(op.id, result.error?.message ?? "Transient error", op.retries + 1);
+              this.emit("outbox.failed", {
+                opId: op.id,
+                error: result.error?.message ?? "Transient error",
+                retriesLeft: op.maxRetries - op.retries - 1
+              });
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "Unknown error";
+          await this.storage.nack(op.id, msg, op.retries + 1);
+          if (op.retries + 1 >= op.maxRetries) {
+            this.emit("outbox.failed", { opId: op.id, error: msg, retriesLeft: 0 });
+            if (op.type === "message.send") {
+              this.emit("message.failed", { clientId: op.id, error: msg });
+            }
+          }
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  get outboxSize() {
+    return this.storage.getPendingCount();
+  }
+  // ── Sync engine ───────────────────────────────────────────
+  async sync() {
+    if (this._syncState === "syncing" || !this._isOnline) return;
+    this._syncState = "syncing";
+    this.emit("sync.start", void 0);
+    let totalNew = 0;
+    let totalUpdated = 0;
+    try {
+      let cursor = await this.storage.getCursor("global_sync") ?? "0";
+      let hasMore = true;
+      while (hasMore) {
+        const result = await this.networkRequest(
+          "GET",
+          "/api/im/sync",
+          void 0,
+          { since: cursor, limit: "100" }
+        );
+        if (!result.ok || !result.data) {
+          throw new Error(result.error?.message ?? "Sync failed");
+        }
+        const { events, cursor: newCursor, hasMore: more } = result.data;
+        for (const event of events) {
+          await this.applySyncEvent(event);
+          if (event.type === "message.new") totalNew++;
+          if (event.type.startsWith("conversation.")) totalUpdated++;
+        }
+        cursor = String(newCursor);
+        await this.storage.setCursor("global_sync", cursor);
+        hasMore = more;
+        this.emit("sync.progress", { synced: events.length, total: events.length });
+      }
+      this._syncState = "idle";
+      this.emit("sync.complete", { newMessages: totalNew, updatedConversations: totalUpdated });
+    } catch (err) {
+      this._syncState = "error";
+      this.emit("sync.error", {
+        error: err instanceof Error ? err.message : "Sync failed",
+        willRetry: false
+      });
+    }
+  }
+  async applySyncEvent(event) {
+    switch (event.type) {
+      case "message.new": {
+        const msg = event.data;
+        await this.storage.putMessages([{
+          id: msg.id,
+          conversationId: msg.conversationId ?? event.conversationId ?? "",
+          content: msg.content ?? "",
+          type: msg.type ?? "text",
+          senderId: msg.senderId ?? "",
+          parentId: msg.parentId ?? null,
+          status: "confirmed",
+          metadata: msg.metadata,
+          createdAt: msg.createdAt ?? event.at,
+          syncSeq: event.seq
+        }]);
+        break;
+      }
+      case "message.edit": {
+        const existing = await this.storage.getMessage(event.data.id);
+        if (existing) {
+          const hasLocalEdits = existing.status !== "confirmed";
+          if (hasLocalEdits && this.options.onConflict) {
+            const resolution = this.options.onConflict(existing, event);
+            if (resolution === "keep_local") break;
+            if (resolution !== "accept_remote" && typeof resolution === "object") {
+              resolution.syncSeq = event.seq;
+              await this.storage.putMessages([resolution]);
+              break;
+            }
+          }
+          existing.content = event.data.content ?? existing.content;
+          existing.updatedAt = event.at;
+          existing.syncSeq = event.seq;
+          await this.storage.putMessages([existing]);
+        }
+        break;
+      }
+      case "message.delete": {
+        if (event.data?.id) await this.storage.deleteMessage(event.data.id);
+        break;
+      }
+      case "conversation.create":
+      case "conversation.update": {
+        const conv = event.data;
+        await this.storage.putConversations([{
+          id: conv.id ?? event.conversationId ?? "",
+          type: conv.type ?? "direct",
+          title: conv.title,
+          unreadCount: conv.unreadCount ?? 0,
+          members: conv.members,
+          metadata: conv.metadata,
+          syncSeq: event.seq,
+          updatedAt: event.at,
+          lastMessageAt: conv.lastMessageAt
+        }]);
+        break;
+      }
+      case "conversation.archive": {
+        const convId = event.data?.id ?? event.conversationId;
+        if (convId) {
+          const existing = await this.storage.getConversation(convId);
+          if (existing) {
+            existing.metadata = { ...existing.metadata, _archived: true };
+            existing.syncSeq = event.seq;
+            existing.updatedAt = event.at;
+            await this.storage.putConversations([existing]);
+          }
+        }
+        break;
+      }
+      case "participant.add": {
+        const convId = event.data?.conversationId ?? event.conversationId;
+        if (convId) {
+          const existing = await this.storage.getConversation(convId);
+          if (existing && existing.members) {
+            const already = existing.members.find((m) => m.userId === event.data.userId);
+            if (!already) {
+              existing.members.push({
+                userId: event.data.userId,
+                username: event.data.username ?? "",
+                displayName: event.data.displayName,
+                role: event.data.role ?? "member"
+              });
+              existing.syncSeq = event.seq;
+              existing.updatedAt = event.at;
+              await this.storage.putConversations([existing]);
+            }
+          }
+        }
+        break;
+      }
+      case "participant.remove": {
+        const convId = event.data?.conversationId ?? event.conversationId;
+        if (convId) {
+          const existing = await this.storage.getConversation(convId);
+          if (existing && existing.members) {
+            existing.members = existing.members.filter((m) => m.userId !== event.data.userId);
+            existing.syncSeq = event.seq;
+            existing.updatedAt = event.at;
+            await this.storage.putConversations([existing]);
+          }
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Handle a realtime event (from WS/SSE) and store locally.
+   */
+  async handleRealtimeEvent(type, payload) {
+    if (type === "message.new" && payload) {
+      await this.storage.putMessages([{
+        id: payload.id,
+        conversationId: payload.conversationId ?? "",
+        content: payload.content ?? "",
+        type: payload.type ?? "text",
+        senderId: payload.senderId ?? "",
+        parentId: payload.parentId ?? null,
+        status: "confirmed",
+        metadata: payload.metadata,
+        createdAt: payload.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      }]);
+    }
+    if (type === "presence.changed" && payload?.userId) {
+      this.presenceCache.set(payload.userId, {
+        status: payload.status ?? "offline",
+        lastSeen: payload.lastSeen ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.emit("presence.changed", payload);
+    }
+  }
+  /**
+   * Get cached presence status for a user.
+   */
+  getPresence(userId) {
+    return this.presenceCache.get(userId) ?? null;
+  }
+  /**
+   * Search messages in local storage.
+   */
+  async searchMessages(query, opts) {
+    if (this.storage.searchMessages) {
+      return this.storage.searchMessages(query, opts);
+    }
+    return [];
+  }
+  /**
+   * Get storage size and quota info.
+   */
+  async getQuotaStatus() {
+    const limit = this.options.quota?.maxStorageBytes ?? 500 * 1024 * 1024;
+    const threshold = this.options.quota?.warningThreshold ?? 0.9;
+    if (this.storage.getStorageSize) {
+      const size = await this.storage.getStorageSize();
+      const percentage = size.total / limit;
+      return {
+        used: size.total,
+        limit,
+        percentage,
+        warning: percentage >= threshold,
+        exceeded: percentage >= 1
+      };
+    }
+    return { used: 0, limit, percentage: 0, warning: false, exceeded: false };
+  }
+  /**
+   * Clear old messages for a conversation (user-initiated quota management).
+   */
+  async clearOldMessages(conversationId, keepCount) {
+    if (this.storage.clearOldMessages) {
+      return this.storage.clearOldMessages(conversationId, keepCount);
+    }
+    return 0;
+  }
+  // ── Read cache ────────────────────────────────────────────
+  async readFromCache(path, query) {
+    if (/\/api\/im\/conversations$/.test(path)) {
+      const convos = await this.storage.getConversations({ limit: 50 });
+      if (convos.length > 0) return { ok: true, data: convos };
+    }
+    const msgMatch = path.match(/\/api\/im\/messages\/([^/]+)$/);
+    if (msgMatch) {
+      const convId = msgMatch[1];
+      const limit = query?.limit ? parseInt(query.limit) : 50;
+      const messages = await this.storage.getMessages(convId, { limit, before: query?.before });
+      if (messages.length > 0) return { ok: true, data: messages };
+    }
+    if (/\/api\/im\/contacts$/.test(path)) {
+      const contacts = await this.storage.getContacts();
+      if (contacts.length > 0) return { ok: true, data: contacts };
+    }
+    return null;
+  }
+  async cacheReadResult(path, _query, result) {
+    if (!result?.ok || !result?.data) return;
+    try {
+      if (/\/api\/im\/conversations$/.test(path) && Array.isArray(result.data)) {
+        const convos = result.data.map((c) => ({
+          id: c.id,
+          type: c.type ?? "direct",
+          title: c.title,
+          lastMessage: c.lastMessage,
+          lastMessageAt: c.lastMessageAt ?? c.updatedAt,
+          unreadCount: c.unreadCount ?? 0,
+          members: c.members,
+          metadata: c.metadata,
+          updatedAt: c.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        await this.storage.putConversations(convos);
+      }
+      const msgMatch = path.match(/\/api\/im\/messages\/([^/]+)$/);
+      if (msgMatch && Array.isArray(result.data)) {
+        const messages = result.data.map((m) => ({
+          id: m.id,
+          conversationId: m.conversationId ?? msgMatch[1],
+          content: m.content ?? "",
+          type: m.type ?? "text",
+          senderId: m.senderId ?? "",
+          parentId: m.parentId ?? null,
+          status: "confirmed",
+          metadata: m.metadata,
+          createdAt: m.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        await this.storage.putMessages(messages);
+      }
+      if (/\/api\/im\/contacts$/.test(path) && Array.isArray(result.data)) {
+        await this.storage.putContacts(result.data);
+      }
+    } catch {
+    }
+  }
+  // ── SSE continuous sync ────────────────────────────────────
+  /**
+   * Start continuous sync via SSE (Server-Sent Events).
+   * Replaces polling with real-time push when syncMode is 'push'.
+   */
+  async startContinuousSync() {
+    if (this.sseSource) return;
+    if (typeof EventSource === "undefined") {
+      return this.sync();
+    }
+    const token = this.tokenProvider?.();
+    if (!token) {
+      return this.sync();
+    }
+    const cursor = await this.storage.getCursor("global_sync") ?? "0";
+    const baseUrl = this.getBaseUrl();
+    const url = `${baseUrl}/api/im/sync/stream?token=${encodeURIComponent(token)}&since=${cursor}`;
+    this._syncState = "syncing";
+    this.emit("sync.start", void 0);
+    this.sseReconnectAttempts = 0;
+    try {
+      this.sseSource = new EventSource(url);
+      let totalNew = 0;
+      let totalUpdated = 0;
+      this.sseSource.addEventListener("sync", async (e) => {
+        try {
+          const event = JSON.parse(e.data);
+          await this.applySyncEvent(event);
+          await this.storage.setCursor("global_sync", String(event.seq));
+          if (event.type === "message.new") totalNew++;
+          if (event.type.startsWith("conversation.")) totalUpdated++;
+          this.emit("sync.progress", { synced: 1, total: 1 });
+          if (this.options.quota) {
+            await this.checkQuota();
+          }
+        } catch {
+        }
+      });
+      this.sseSource.addEventListener("caught_up", () => {
+        this._syncState = "idle";
+        this.sseReconnectAttempts = 0;
+        this.emit("sync.complete", { newMessages: totalNew, updatedConversations: totalUpdated });
+        totalNew = 0;
+        totalUpdated = 0;
+      });
+      this.sseSource.addEventListener("error", () => {
+        this._syncState = "error";
+        this.emit("sync.error", { error: "SSE connection error", willRetry: true });
+      });
+      this.sseSource.onerror = () => {
+        if (this.sseSource?.readyState === EventSource.CLOSED) {
+          this.sseSource = null;
+          this._syncState = "error";
+          this.scheduleSseReconnect();
+        }
+      };
+    } catch (err) {
+      this._syncState = "error";
+      this.emit("sync.error", {
+        error: err instanceof Error ? err.message : "SSE init failed",
+        willRetry: true
+      });
+      this.scheduleSseReconnect();
+    }
+  }
+  /**
+   * Stop the SSE continuous sync connection.
+   */
+  stopContinuousSync() {
+    if (this.sseSource) {
+      this.sseSource.close();
+      this.sseSource = null;
+    }
+    if (this.sseReconnectTimer) {
+      clearTimeout(this.sseReconnectTimer);
+      this.sseReconnectTimer = null;
+    }
+    this._syncState = "idle";
+  }
+  scheduleSseReconnect() {
+    if (!this._isOnline) return;
+    this.sseReconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.sseReconnectAttempts - 1), 3e4);
+    this.sseReconnectTimer = setTimeout(() => {
+      this.sseReconnectTimer = null;
+      if (this._isOnline) this.startContinuousSync();
+    }, delay);
+  }
+  /** Get the base URL for SSE connections (strip /api/im prefix). */
+  getBaseUrl() {
+    return typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
+  }
+  // ── Quota check ─────────────────────────────────────────────
+  async checkQuota() {
+    if (!this.options.quota || !this.storage.getStorageSize) return;
+    const size = await this.storage.getStorageSize();
+    const limit = this.options.quota.maxStorageBytes;
+    const threshold = this.options.quota.warningThreshold;
+    const pct = size.total / limit;
+    if (pct >= 1) {
+      this.emit("quota.exceeded", { used: size.total, limit });
+    } else if (pct >= threshold) {
+      this.emit("quota.warning", { used: size.total, limit, percentage: pct });
+    }
+  }
+};
+var AttachmentQueue = class {
+  constructor(offline, networkRequest) {
+    this.offline = offline;
+    this.networkRequest = networkRequest;
+    this.queue = /* @__PURE__ */ new Map();
+    this.uploading = false;
+  }
+  /**
+   * Queue a file attachment for offline upload.
+   * Returns the queued attachment with a local ID.
+   */
+  async queueAttachment(conversationId, file, messageContent) {
+    const id = generateId();
+    const attachment = {
+      id,
+      conversationId,
+      file: { name: file.name, size: file.size, type: file.type },
+      data: file.data,
+      status: "pending",
+      progress: 0,
+      messageClientId: generateId(),
+      createdAt: Date.now()
+    };
+    this.queue.set(id, attachment);
+    await this.offline.storage.putMessages([{
+      id: `local-${attachment.messageClientId}`,
+      clientId: attachment.messageClientId,
+      conversationId,
+      content: messageContent ?? `[File: ${file.name}]`,
+      type: "file",
+      senderId: "__self__",
+      status: "pending",
+      metadata: { _attachmentId: id, fileName: file.name, fileSize: file.size },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }]);
+    if (this.offline.isOnline) this.processQueue();
+    return attachment;
+  }
+  /** Process pending uploads. */
+  async processQueue() {
+    if (this.uploading || !this.offline.isOnline) return;
+    this.uploading = true;
+    try {
+      for (const [id, att] of this.queue) {
+        if (att.status !== "pending") continue;
+        att.status = "uploading";
+        try {
+          const presign = await this.networkRequest(
+            "POST",
+            "/api/im/files/presign",
+            { fileName: att.file.name, fileSize: att.file.size, mimeType: att.file.type }
+          );
+          if (!presign.ok || !presign.data?.uploadUrl) {
+            throw new Error(presign.error?.message ?? "Presign failed");
+          }
+          if (att.data) {
+            await fetch(presign.data.uploadUrl, {
+              method: "PUT",
+              body: att.data,
+              headers: { "Content-Type": att.file.type }
+            });
+          }
+          att.progress = 80;
+          const confirm = await this.networkRequest(
+            "POST",
+            "/api/im/files/confirm",
+            { uploadId: presign.data.uploadId }
+          );
+          if (!confirm.ok) {
+            throw new Error(confirm.error?.message ?? "Confirm failed");
+          }
+          att.status = "uploaded";
+          att.progress = 100;
+          await this.networkRequest(
+            "POST",
+            `/api/im/messages/${att.conversationId}`,
+            {
+              type: "file",
+              content: `[File: ${att.file.name}]`,
+              metadata: {
+                fileUrl: confirm.data?.url ?? presign.data.downloadUrl,
+                fileName: att.file.name,
+                fileSize: att.file.size,
+                mimeType: att.file.type,
+                uploadId: presign.data.uploadId
+              }
+            }
+          );
+          await this.offline.storage.deleteMessage(`local-${att.messageClientId}`);
+          this.queue.delete(id);
+        } catch (err) {
+          att.status = "failed";
+          att.error = err instanceof Error ? err.message : "Upload failed";
+        }
+      }
+    } finally {
+      this.uploading = false;
+    }
+  }
+  /** Get all queued attachments. */
+  getQueue() {
+    return Array.from(this.queue.values());
+  }
+  /** Retry a failed attachment upload. */
+  async retry(attachmentId) {
+    const att = this.queue.get(attachmentId);
+    if (att && att.status === "failed") {
+      att.status = "pending";
+      att.error = void 0;
+      if (this.offline.isOnline) this.processQueue();
+    }
+  }
+  /** Cancel and remove a queued attachment. */
+  async cancel(attachmentId) {
+    const att = this.queue.get(attachmentId);
+    if (att) {
+      await this.offline.storage.deleteMessage(`local-${att.messageClientId}`);
+      this.queue.delete(attachmentId);
+    }
+  }
+};
+
+// src/community-hub.ts
+var CommunityHub = class {
+  constructor(_r, config) {
+    this._r = _r;
+    this.feedCache = /* @__PURE__ */ new Map();
+    this.statsCache = null;
+    this.notifCountCache = null;
+    this.notifCountTTL = 15e3;
+    this.wsUnsubs = [];
+    this.feedTTL = config?.feedTTLMs ?? 3e5;
+    this.statsTTL = config?.statsTTLMs ?? 6e5;
+  }
+  /** Invalidate cached feeds/stats (e.g. after you posted). */
+  invalidateCache(boardId) {
+    if (boardId) this.feedCache.delete(boardId);
+    else this.feedCache.clear();
+    this.statsCache = null;
+    this.notifCountCache = null;
+  }
+  /**
+   * Subscribe to community.* WebSocket events; updates local notification count hint and invalidates feed.
+   */
+  attachRealtime(ws) {
+    const onReply = () => {
+      this.notifCountCache = null;
+      this.feedCache.clear();
+    };
+    const types = [
+      "community.reply",
+      "community.vote",
+      "community.answer.accepted",
+      "community.mention"
+    ];
+    for (const t of types) {
+      ws.on(t, onReply);
+      this.wsUnsubs.push(() => ws.off(t, onReply));
+    }
+  }
+  detachRealtime() {
+    for (const u of this.wsUnsubs) u();
+    this.wsUnsubs = [];
+  }
+  // ─── Intent (cached reads) ─────────────────────────────────
+  async feed(opts) {
+    const key = opts?.boardId ?? "__all__";
+    const hit = this.feedCache.get(key);
+    if (hit && Date.now() - hit.at < this.feedTTL) {
+      return { ok: true, data: hit.payload };
+    }
+    const res = await this.listPosts({
+      boardId: opts?.boardId,
+      limit: opts?.limit ?? 20,
+      sort: "hot"
+    });
+    if (res.ok && res.data != null) {
+      this.feedCache.set(key, { at: Date.now(), payload: res.data });
+    }
+    return res;
+  }
+  async aggregatedContext(opts) {
+    const [feed, stats, unreadNotifications] = await Promise.all([
+      this.feed({ boardId: opts?.boardId, limit: opts?.feedLimit ?? 15 }),
+      this.statsCached(),
+      this.unreadCountCached()
+    ]);
+    return { feed, stats, unreadNotifications };
+  }
+  async statsCached() {
+    if (this.statsCache && Date.now() - this.statsCache.at < this.statsTTL) {
+      return { ok: true, data: this.statsCache.data };
+    }
+    const res = await this.getStats();
+    if (res.ok && res.data != null) {
+      this.statsCache = { at: Date.now(), data: res.data };
+    }
+    return res;
+  }
+  async unreadCountCached() {
+    if (this.notifCountCache && Date.now() - this.notifCountCache.at < this.notifCountTTL) {
+      return { ok: true, data: { unread: this.notifCountCache.count } };
+    }
+    const res = await this.getNotificationCount();
+    const n = res.data?.unread;
+    if (res.ok && typeof n === "number") {
+      this.notifCountCache = { at: Date.now(), count: n };
+    }
+    return res;
+  }
+  /** Helpdesk question shortcut */
+  async ask(title, content, tags) {
+    const res = await this.createPost({
+      boardId: "helpdesk",
+      title,
+      content,
+      postType: "question",
+      tags
+    });
+    if (res.ok) this.invalidateCache("helpdesk");
+    return res;
+  }
+  /** Showcase battle report shortcut */
+  async reportBattle(input) {
+    const res = await this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "battleReport",
+      tags: input.tags,
+      linkedGeneIds: input.linkedGeneIds,
+      linkedAgentId: input.linkedAgentId
+    });
+    if (res.ok) this.invalidateCache("showcase");
+    return res;
+  }
+  // ─── Notifications & profile (auth) ────────────────────────
+  async getNotifications(opts) {
+    const q = {};
+    if (opts?.unread) q.unread = "true";
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    if (opts?.offset != null) q.offset = String(opts.offset);
+    return this._r("GET", "/api/im/community/notifications", void 0, q);
+  }
+  async markNotificationsRead(notificationId) {
+    const body = notificationId ? { notificationId } : {};
+    return this._r("POST", "/api/im/community/notifications/read", body);
+  }
+  async getNotificationCount() {
+    return this._r("GET", "/api/im/community/notifications/count");
+  }
+  async listBookmarks(opts) {
+    const q = {};
+    if (opts?.cursor) q.cursor = opts.cursor;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/bookmarks", void 0, q);
+  }
+  async followToggle(followingId, followingType) {
+    return this._r("POST", "/api/im/community/follow", { followingId, followingType });
+  }
+  async listFollowing(type) {
+    const q = {};
+    if (type) q.type = type;
+    return this._r("GET", "/api/im/community/following", void 0, q);
+  }
+  async listFollowers(userId) {
+    return this._r("GET", `/api/im/community/followers/${encodeURIComponent(userId)}`);
+  }
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/community/profile/${encodeURIComponent(userId)}`);
+  }
+  // ─── REST (same surface as former CommunityClient) ─────────
+  async createPost(input) {
+    return this._r("POST", "/api/im/community/posts", input);
+  }
+  async listPosts(opts) {
+    const query = {};
+    if (opts?.boardId) query.boardId = opts.boardId;
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.period) query.period = opts.period;
+    if (opts?.authorType) query.authorType = opts.authorType;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/posts", void 0, query);
+  }
+  async getPost(postId) {
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async updatePost(postId, input) {
+    return this._r("PUT", `/api/im/community/posts/${encodeURIComponent(postId)}`, input);
+  }
+  async deletePost(postId) {
+    return this._r("DELETE", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async createComment(postId, input) {
+    return this._r("POST", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, input);
+  }
+  async listComments(postId, opts) {
+    const query = {};
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, void 0, query);
+  }
+  async markBestAnswer(commentId) {
+    return this._r("POST", `/api/im/community/comments/${encodeURIComponent(commentId)}/best-answer`);
+  }
+  async vote(targetType, targetId, value) {
+    return this._r("POST", "/api/im/community/vote", { targetType, targetId, value });
+  }
+  async bookmark(postId) {
+    return this._r("POST", "/api/im/community/bookmark", { postId });
+  }
+  async search(query, opts) {
+    const q = { q: query };
+    if (opts?.boardId) q.boardId = opts.boardId;
+    if (opts?.sort) q.sort = opts.sort;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/search", void 0, q);
+  }
+  async updateComment(commentId, input) {
+    return this._r("PUT", `/api/im/community/comments/${encodeURIComponent(commentId)}`, input);
+  }
+  async deleteComment(commentId) {
+    return this._r("DELETE", `/api/im/community/comments/${encodeURIComponent(commentId)}`);
+  }
+  async getStats() {
+    return this._r("GET", "/api/im/community/stats");
+  }
+  async getTrendingTags(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/tags/trending", void 0, query);
+  }
+  async getHotPosts(opts) {
+    const query = {};
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    if (opts?.period) query.period = opts.period;
+    return this._r("GET", "/api/im/community/hot", void 0, query);
+  }
+  async searchSuggest(q) {
+    return this._r("GET", "/api/im/community/search/suggest", void 0, { q });
+  }
+  async autocompleteGenes(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/genes", void 0, query);
+  }
+  async autocompleteSkills(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/skills", void 0, query);
+  }
+  async createBattleReport(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: `Battle Report: ${input.agentId}`,
+      content: input.narrative || "Auto-generated battle report",
+      postType: "battleReport",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId
+    });
+  }
+  async createMilestone(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "milestone",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId,
+      tags: input.tags
+    });
+  }
+  async createGeneRelease(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "geneRelease",
+      linkedGeneIds: [input.geneId],
+      tags: input.tags
+    });
+  }
+};
+
+// src/aip.ts
+import {
+  AIPIdentity
+} from "@prismer/aip-sdk";
+import {
+  publicKeyToDIDKey,
+  didKeyToPublicKey,
+  validateDIDKey
+} from "@prismer/aip-sdk";
+import {
+  buildCredential,
+  buildPresentation,
+  verifyCredential,
+  verifyPresentation
+} from "@prismer/aip-sdk";
+import {
+  buildDelegation,
+  buildEphemeralDelegation,
+  verifyDelegation,
+  verifyEphemeralDelegation
+} from "@prismer/aip-sdk";
+import { AIPIdentity as AIPIdentity2 } from "@prismer/aip-sdk";
+
+// src/types.ts
+var ENVIRONMENTS = {
+  production: "https://prismer.cloud"
+};
+
+// src/storage.ts
+var MemoryStorage = class {
+  constructor() {
+    this.messages = /* @__PURE__ */ new Map();
+    this.conversations = /* @__PURE__ */ new Map();
+    this.contacts = /* @__PURE__ */ new Map();
+    this.cursors = /* @__PURE__ */ new Map();
+    this.outbox = /* @__PURE__ */ new Map();
+  }
+  async init() {
+  }
+  // ── Messages ────────────────────────────────────────────────
+  async putMessages(messages) {
+    for (const m of messages) this.messages.set(m.id, { ...m });
+  }
+  async getMessages(conversationId, opts) {
+    const all = Array.from(this.messages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    if (opts.before) {
+      const idx = all.findIndex((m) => m.id === opts.before);
+      if (idx > 0) return all.slice(Math.max(0, idx - opts.limit), idx);
+    }
+    return all.slice(-opts.limit);
+  }
+  async getMessage(messageId) {
+    return this.messages.get(messageId) ?? null;
+  }
+  async deleteMessage(messageId) {
+    this.messages.delete(messageId);
+  }
+  // ── Conversations ───────────────────────────────────────────
+  async putConversations(conversations) {
+    for (const c of conversations) this.conversations.set(c.id, { ...c });
+  }
+  async getConversations(opts) {
+    const all = Array.from(this.conversations.values()).sort((a, b) => (b.lastMessageAt ?? b.updatedAt).localeCompare(a.lastMessageAt ?? a.updatedAt));
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    return all.slice(offset, offset + limit);
+  }
+  async getConversation(id) {
+    return this.conversations.get(id) ?? null;
+  }
+  // ── Contacts ────────────────────────────────────────────────
+  async putContacts(contacts) {
+    for (const c of contacts) this.contacts.set(c.userId, { ...c });
+  }
+  async getContacts() {
+    return Array.from(this.contacts.values());
+  }
+  // ── Cursors ─────────────────────────────────────────────────
+  async getCursor(key) {
+    return this.cursors.get(key) ?? null;
+  }
+  async setCursor(key, value) {
+    this.cursors.set(key, value);
+  }
+  // ── Outbox ──────────────────────────────────────────────────
+  async enqueue(op) {
+    this.outbox.set(op.id, { ...op });
+  }
+  async dequeueReady(limit) {
+    const ready = Array.from(this.outbox.values()).filter((op) => op.status === "pending").sort((a, b) => a.createdAt - b.createdAt).slice(0, limit);
+    for (const op of ready) {
+      op.status = "inflight";
+      this.outbox.set(op.id, op);
+    }
+    return ready;
+  }
+  async ack(opId) {
+    this.outbox.delete(opId);
+  }
+  async nack(opId, error, retries) {
+    const op = this.outbox.get(opId);
+    if (!op) return;
+    op.retries = retries;
+    op.lastError = error;
+    op.status = retries >= op.maxRetries ? "failed" : "pending";
+    this.outbox.set(opId, op);
+  }
+  async getPendingCount() {
+    return Array.from(this.outbox.values()).filter((op) => op.status === "pending" || op.status === "inflight").length;
+  }
+  // ── Search ─────────────────────────────────────────────────
+  async searchMessages(query, opts) {
+    const lower = query.toLowerCase();
+    const limit = opts?.limit ?? 50;
+    return Array.from(this.messages.values()).filter((m) => {
+      if (opts?.conversationId && m.conversationId !== opts.conversationId) return false;
+      return (m.content ?? "").toLowerCase().includes(lower);
+    }).sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit);
+  }
+  // ── Quota ─────────────────────────────────────────────────
+  async getStorageSize() {
+    const msgSize = this.messages.size * 500;
+    const convSize = this.conversations.size * 200;
+    return { messages: msgSize, conversations: convSize, total: msgSize + convSize };
+  }
+  async clearOldMessages(conversationId, keepCount) {
+    const msgs = Array.from(this.messages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const toDelete = msgs.slice(keepCount);
+    for (const m of toDelete) this.messages.delete(m.id);
+    return toDelete.length;
+  }
+  // ── Lifecycle ───────────────────────────────────────────────
+  async clear() {
+    this.messages.clear();
+    this.conversations.clear();
+    this.contacts.clear();
+    this.cursors.clear();
+    this.outbox.clear();
+  }
+};
+var IDB_STORES = ["messages", "conversations", "contacts", "cursors", "outbox"];
+var IndexedDBStorage = class {
+  constructor(dbName = "prismer-offline", version = 1) {
+    this.dbName = dbName;
+    this.version = version;
+    this.db = null;
+  }
+  async init() {
+    if (typeof indexedDB === "undefined") {
+      throw new Error("IndexedDB is not available in this environment. Use MemoryStorage or SQLiteStorage instead.");
+    }
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this.dbName, this.version);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains("messages")) {
+          const store = db.createObjectStore("messages", { keyPath: "id" });
+          store.createIndex("conversationId", "conversationId", { unique: false });
+          store.createIndex("createdAt", "createdAt", { unique: false });
+        }
+        if (!db.objectStoreNames.contains("conversations")) {
+          db.createObjectStore("conversations", { keyPath: "id" });
+        }
+        if (!db.objectStoreNames.contains("contacts")) {
+          db.createObjectStore("contacts", { keyPath: "userId" });
+        }
+        if (!db.objectStoreNames.contains("cursors")) {
+          db.createObjectStore("cursors", { keyPath: "key" });
+        }
+        if (!db.objectStoreNames.contains("outbox")) {
+          const store = db.createObjectStore("outbox", { keyPath: "id" });
+          store.createIndex("status", "status", { unique: false });
+          store.createIndex("createdAt", "createdAt", { unique: false });
+        }
+      };
+      req.onsuccess = () => {
+        this.db = req.result;
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  tx(stores, mode = "readonly") {
+    if (!this.db) throw new Error("IndexedDB not initialized. Call init() first.");
+    return this.db.transaction(stores, mode);
+  }
+  req(request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  // ── Messages ────────────────────────────────────────────────
+  async putMessages(messages) {
+    const tx = this.tx("messages", "readwrite");
+    const store = tx.objectStore("messages");
+    for (const m of messages) store.put(m);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async getMessages(conversationId, opts) {
+    const tx = this.tx("messages");
+    const store = tx.objectStore("messages");
+    const idx = store.index("conversationId");
+    const all = await this.req(idx.getAll(conversationId));
+    all.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    if (opts.before) {
+      const i = all.findIndex((m) => m.id === opts.before);
+      if (i > 0) return all.slice(Math.max(0, i - opts.limit), i);
+    }
+    return all.slice(-opts.limit);
+  }
+  async getMessage(messageId) {
+    const tx = this.tx("messages");
+    const result = await this.req(tx.objectStore("messages").get(messageId));
+    return result ?? null;
+  }
+  async deleteMessage(messageId) {
+    const tx = this.tx("messages", "readwrite");
+    tx.objectStore("messages").delete(messageId);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  // ── Conversations ───────────────────────────────────────────
+  async putConversations(conversations) {
+    const tx = this.tx("conversations", "readwrite");
+    const store = tx.objectStore("conversations");
+    for (const c of conversations) store.put(c);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async getConversations(opts) {
+    const tx = this.tx("conversations");
+    const all = await this.req(tx.objectStore("conversations").getAll());
+    all.sort((a, b) => (b.lastMessageAt ?? b.updatedAt).localeCompare(a.lastMessageAt ?? a.updatedAt));
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    return all.slice(offset, offset + limit);
+  }
+  async getConversation(id) {
+    const tx = this.tx("conversations");
+    const result = await this.req(tx.objectStore("conversations").get(id));
+    return result ?? null;
+  }
+  // ── Contacts ────────────────────────────────────────────────
+  async putContacts(contacts) {
+    const tx = this.tx("contacts", "readwrite");
+    const store = tx.objectStore("contacts");
+    for (const c of contacts) store.put(c);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async getContacts() {
+    const tx = this.tx("contacts");
+    return this.req(tx.objectStore("contacts").getAll());
+  }
+  // ── Cursors ─────────────────────────────────────────────────
+  async getCursor(key) {
+    const tx = this.tx("cursors");
+    const result = await this.req(tx.objectStore("cursors").get(key));
+    return result?.value ?? null;
+  }
+  async setCursor(key, value) {
+    const tx = this.tx("cursors", "readwrite");
+    tx.objectStore("cursors").put({ key, value });
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  // ── Outbox ──────────────────────────────────────────────────
+  async enqueue(op) {
+    const tx = this.tx("outbox", "readwrite");
+    tx.objectStore("outbox").put(op);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async dequeueReady(limit) {
+    const tx = this.tx("outbox", "readwrite");
+    const store = tx.objectStore("outbox");
+    const idx = store.index("status");
+    const pending = await this.req(idx.getAll("pending"));
+    pending.sort((a, b) => a.createdAt - b.createdAt);
+    const batch = pending.slice(0, limit);
+    for (const op of batch) {
+      op.status = "inflight";
+      store.put(op);
+    }
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve(batch);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async ack(opId) {
+    const tx = this.tx("outbox", "readwrite");
+    tx.objectStore("outbox").delete(opId);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async nack(opId, error, retries) {
+    const tx = this.tx("outbox", "readwrite");
+    const store = tx.objectStore("outbox");
+    const op = await this.req(store.get(opId));
+    if (!op) return;
+    op.retries = retries;
+    op.lastError = error;
+    op.status = retries >= op.maxRetries ? "failed" : "pending";
+    store.put(op);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async getPendingCount() {
+    const tx = this.tx("outbox");
+    const idx = tx.objectStore("outbox").index("status");
+    const pending = await this.req(idx.count("pending"));
+    const inflight = await this.req(idx.count("inflight"));
+    return pending + inflight;
+  }
+  // ── Search ─────────────────────────────────────────────────
+  async searchMessages(query, opts) {
+    const lower = query.toLowerCase();
+    const limit = opts?.limit ?? 50;
+    const tx = this.tx("messages");
+    let all;
+    if (opts?.conversationId) {
+      const idx = tx.objectStore("messages").index("conversationId");
+      all = await this.req(idx.getAll(opts.conversationId));
+    } else {
+      all = await this.req(tx.objectStore("messages").getAll());
+    }
+    return all.filter((m) => (m.content ?? "").toLowerCase().includes(lower)).sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit);
+  }
+  // ── Quota ─────────────────────────────────────────────────
+  async getStorageSize() {
+    if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
+      const est = await navigator.storage.estimate();
+      const total = est.usage ?? 0;
+      return { messages: Math.floor(total * 0.8), conversations: Math.floor(total * 0.2), total };
+    }
+    const tx = this.tx(["messages", "conversations"]);
+    const msgCount = await this.req(tx.objectStore("messages").count());
+    const convCount = await this.req(tx.objectStore("conversations").count());
+    return { messages: msgCount * 500, conversations: convCount * 200, total: msgCount * 500 + convCount * 200 };
+  }
+  async clearOldMessages(conversationId, keepCount) {
+    const tx = this.tx("messages", "readwrite");
+    const store = tx.objectStore("messages");
+    const idx = store.index("conversationId");
+    const all = await this.req(idx.getAll(conversationId));
+    all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const toDelete = all.slice(keepCount);
+    for (const m of toDelete) store.delete(m.id);
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve(toDelete.length);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  // ── Lifecycle ───────────────────────────────────────────────
+  async clear() {
+    const tx = this.tx(IDB_STORES, "readwrite");
+    for (const name of IDB_STORES) tx.objectStore(name).clear();
+    return new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+};
+var SQLiteStorage = class {
+  constructor(dbPath = "prismer-offline.db") {
+    this.db = null;
+    this.dbPath = dbPath;
+  }
+  async init() {
+    let Database;
+    try {
+      Database = __require("better-sqlite3");
+    } catch {
+      throw new Error(
+        'SQLiteStorage requires the "better-sqlite3" package. Install it with: npm install better-sqlite3\nFor browser environments, use IndexedDBStorage instead.'
+      );
+    }
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        clientId TEXT,
+        conversationId TEXT NOT NULL,
+        content TEXT,
+        type TEXT DEFAULT 'text',
+        senderId TEXT,
+        parentId TEXT,
+        status TEXT DEFAULT 'confirmed',
+        metadata TEXT,
+        createdAt TEXT,
+        updatedAt TEXT,
+        syncSeq INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_msg_conv ON messages(conversationId, createdAt);
+      CREATE INDEX IF NOT EXISTS idx_msg_created ON messages(createdAt);
+
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        type TEXT DEFAULT 'direct',
+        title TEXT,
+        lastMessage TEXT,
+        lastMessageAt TEXT,
+        unreadCount INTEGER DEFAULT 0,
+        lastReadMessageId TEXT,
+        members TEXT,
+        metadata TEXT,
+        syncSeq INTEGER,
+        updatedAt TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS contacts (
+        userId TEXT PRIMARY KEY,
+        username TEXT,
+        displayName TEXT,
+        role TEXT,
+        conversationId TEXT,
+        lastMessageAt TEXT,
+        unreadCount INTEGER DEFAULT 0,
+        syncSeq INTEGER
+      );
+
+      CREATE TABLE IF NOT EXISTS cursors (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS outbox (
+        id TEXT PRIMARY KEY,
+        type TEXT,
+        method TEXT,
+        path TEXT,
+        body TEXT,
+        query TEXT,
+        status TEXT DEFAULT 'pending',
+        createdAt INTEGER,
+        retries INTEGER DEFAULT 0,
+        maxRetries INTEGER DEFAULT 5,
+        lastError TEXT,
+        idempotencyKey TEXT,
+        localData TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_outbox_status ON outbox(status, createdAt);
+    `);
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+        content, id UNINDEXED, conversationId UNINDEXED
+      );
+    `);
+  }
+  ensureDb() {
+    if (!this.db) throw new Error("SQLiteStorage not initialized. Call init() first.");
+    return this.db;
+  }
+  // ── Messages ────────────────────────────────────────────────
+  async putMessages(messages) {
+    const db = this.ensureDb();
+    const insert = db.prepare(`
+      INSERT OR REPLACE INTO messages (id, clientId, conversationId, content, type, senderId, parentId, status, metadata, createdAt, updatedAt, syncSeq)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertFts = db.prepare(`
+      INSERT OR REPLACE INTO messages_fts (rowid, content, id, conversationId)
+      VALUES ((SELECT rowid FROM messages WHERE id = ?), ?, ?, ?)
+    `);
+    const txn = db.transaction((msgs) => {
+      for (const m of msgs) {
+        insert.run(
+          m.id,
+          m.clientId ?? null,
+          m.conversationId,
+          m.content,
+          m.type,
+          m.senderId,
+          m.parentId ?? null,
+          m.status,
+          m.metadata ? JSON.stringify(m.metadata) : null,
+          m.createdAt,
+          m.updatedAt ?? null,
+          m.syncSeq ?? null
+        );
+        if (m.content) {
+          insertFts.run(m.id, m.content, m.id, m.conversationId);
+        }
+      }
+    });
+    txn(messages);
+  }
+  async getMessages(conversationId, opts) {
+    const db = this.ensureDb();
+    let rows;
+    if (opts.before) {
+      const beforeRow = db.prepare("SELECT createdAt FROM messages WHERE id = ?").get(opts.before);
+      if (beforeRow) {
+        rows = db.prepare(
+          "SELECT * FROM messages WHERE conversationId = ? AND createdAt < ? ORDER BY createdAt DESC LIMIT ?"
+        ).all(conversationId, beforeRow.createdAt, opts.limit);
+      } else {
+        rows = db.prepare(
+          "SELECT * FROM messages WHERE conversationId = ? ORDER BY createdAt DESC LIMIT ?"
+        ).all(conversationId, opts.limit);
+      }
+    } else {
+      rows = db.prepare(
+        "SELECT * FROM messages WHERE conversationId = ? ORDER BY createdAt DESC LIMIT ?"
+      ).all(conversationId, opts.limit);
+    }
+    return rows.reverse().map(this.rowToMessage);
+  }
+  async getMessage(messageId) {
+    const db = this.ensureDb();
+    const row = db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    return row ? this.rowToMessage(row) : null;
+  }
+  async deleteMessage(messageId) {
+    const db = this.ensureDb();
+    db.prepare("DELETE FROM messages WHERE id = ?").run(messageId);
+    db.prepare("DELETE FROM messages_fts WHERE id = ?").run(messageId);
+  }
+  rowToMessage(row) {
+    return {
+      id: row.id,
+      clientId: row.clientId ?? void 0,
+      conversationId: row.conversationId,
+      content: row.content ?? "",
+      type: row.type ?? "text",
+      senderId: row.senderId ?? "",
+      parentId: row.parentId ?? null,
+      status: row.status ?? "confirmed",
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt ?? "",
+      updatedAt: row.updatedAt ?? void 0,
+      syncSeq: row.syncSeq ?? void 0
+    };
+  }
+  // ── Conversations ───────────────────────────────────────────
+  async putConversations(conversations) {
+    const db = this.ensureDb();
+    const insert = db.prepare(`
+      INSERT OR REPLACE INTO conversations (id, type, title, lastMessage, lastMessageAt, unreadCount, lastReadMessageId, members, metadata, syncSeq, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const txn = db.transaction((convs) => {
+      for (const c of convs) {
+        insert.run(
+          c.id,
+          c.type,
+          c.title ?? null,
+          c.lastMessage ? JSON.stringify(c.lastMessage) : null,
+          c.lastMessageAt ?? null,
+          c.unreadCount,
+          c.lastReadMessageId ?? null,
+          c.members ? JSON.stringify(c.members) : null,
+          c.metadata ? JSON.stringify(c.metadata) : null,
+          c.syncSeq ?? null,
+          c.updatedAt
+        );
+      }
+    });
+    txn(conversations);
+  }
+  async getConversations(opts) {
+    const db = this.ensureDb();
+    const limit = opts?.limit ?? 50;
+    const offset = opts?.offset ?? 0;
+    const rows = db.prepare(
+      "SELECT * FROM conversations ORDER BY COALESCE(lastMessageAt, updatedAt) DESC LIMIT ? OFFSET ?"
+    ).all(limit, offset);
+    return rows.map(this.rowToConversation);
+  }
+  async getConversation(id) {
+    const db = this.ensureDb();
+    const row = db.prepare("SELECT * FROM conversations WHERE id = ?").get(id);
+    return row ? this.rowToConversation(row) : null;
+  }
+  rowToConversation(row) {
+    return {
+      id: row.id,
+      type: row.type ?? "direct",
+      title: row.title ?? void 0,
+      lastMessage: row.lastMessage ? JSON.parse(row.lastMessage) : void 0,
+      lastMessageAt: row.lastMessageAt ?? void 0,
+      unreadCount: row.unreadCount ?? 0,
+      lastReadMessageId: row.lastReadMessageId ?? void 0,
+      members: row.members ? JSON.parse(row.members) : void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      syncSeq: row.syncSeq ?? void 0,
+      updatedAt: row.updatedAt ?? ""
+    };
+  }
+  // ── Contacts ────────────────────────────────────────────────
+  async putContacts(contacts) {
+    const db = this.ensureDb();
+    const insert = db.prepare(`
+      INSERT OR REPLACE INTO contacts (userId, username, displayName, role, conversationId, lastMessageAt, unreadCount, syncSeq)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const txn = db.transaction((cs) => {
+      for (const c of cs) {
+        insert.run(
+          c.userId,
+          c.username,
+          c.displayName,
+          c.role,
+          c.conversationId,
+          c.lastMessageAt ?? null,
+          c.unreadCount,
+          c.syncSeq ?? null
+        );
+      }
+    });
+    txn(contacts);
+  }
+  async getContacts() {
+    const db = this.ensureDb();
+    return db.prepare("SELECT * FROM contacts").all().map((row) => ({
+      userId: row.userId,
+      username: row.username ?? "",
+      displayName: row.displayName ?? "",
+      role: row.role ?? "member",
+      conversationId: row.conversationId ?? "",
+      lastMessageAt: row.lastMessageAt ?? void 0,
+      unreadCount: row.unreadCount ?? 0,
+      syncSeq: row.syncSeq ?? void 0
+    }));
+  }
+  // ── Cursors ─────────────────────────────────────────────────
+  async getCursor(key) {
+    const db = this.ensureDb();
+    const row = db.prepare("SELECT value FROM cursors WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  async setCursor(key, value) {
+    const db = this.ensureDb();
+    db.prepare("INSERT OR REPLACE INTO cursors (key, value) VALUES (?, ?)").run(key, value);
+  }
+  // ── Outbox ──────────────────────────────────────────────────
+  async enqueue(op) {
+    const db = this.ensureDb();
+    db.prepare(`
+      INSERT OR REPLACE INTO outbox (id, type, method, path, body, query, status, createdAt, retries, maxRetries, lastError, idempotencyKey, localData)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      op.id,
+      op.type,
+      op.method,
+      op.path,
+      op.body ? JSON.stringify(op.body) : null,
+      op.query ? JSON.stringify(op.query) : null,
+      op.status,
+      op.createdAt,
+      op.retries,
+      op.maxRetries,
+      op.lastError ?? null,
+      op.idempotencyKey,
+      op.localData ? JSON.stringify(op.localData) : null
+    );
+  }
+  async dequeueReady(limit) {
+    const db = this.ensureDb();
+    const rows = db.prepare(
+      "SELECT * FROM outbox WHERE status = ? ORDER BY createdAt ASC LIMIT ?"
+    ).all("pending", limit);
+    const ops = rows.map(this.rowToOutbox);
+    const update = db.prepare("UPDATE outbox SET status = ? WHERE id = ?");
+    const txn = db.transaction((items) => {
+      for (const op of items) update.run("inflight", op.id);
+    });
+    txn(ops);
+    return ops.map((op) => ({ ...op, status: "inflight" }));
+  }
+  async ack(opId) {
+    const db = this.ensureDb();
+    db.prepare("DELETE FROM outbox WHERE id = ?").run(opId);
+  }
+  async nack(opId, error, retries) {
+    const db = this.ensureDb();
+    const row = db.prepare("SELECT maxRetries FROM outbox WHERE id = ?").get(opId);
+    const newStatus = row && retries >= row.maxRetries ? "failed" : "pending";
+    db.prepare("UPDATE outbox SET retries = ?, lastError = ?, status = ? WHERE id = ?").run(retries, error, newStatus, opId);
+  }
+  async getPendingCount() {
+    const db = this.ensureDb();
+    const row = db.prepare(
+      "SELECT COUNT(*) as cnt FROM outbox WHERE status IN ('pending', 'inflight')"
+    ).get();
+    return row?.cnt ?? 0;
+  }
+  // ── Search (FTS5) ─────────────────────────────────────────
+  async searchMessages(query, opts) {
+    const db = this.ensureDb();
+    const limit = opts?.limit ?? 50;
+    const safeQuery = query.replace(/['"*(){}[\]^~\\]/g, " ").trim();
+    if (!safeQuery) return [];
+    let rows;
+    if (opts?.conversationId) {
+      rows = db.prepare(`
+        SELECT m.* FROM messages m
+        JOIN messages_fts f ON m.id = f.id
+        WHERE messages_fts MATCH ? AND m.conversationId = ?
+        ORDER BY m.createdAt DESC LIMIT ?
+      `).all(safeQuery, opts.conversationId, limit);
+    } else {
+      rows = db.prepare(`
+        SELECT m.* FROM messages m
+        JOIN messages_fts f ON m.id = f.id
+        WHERE messages_fts MATCH ?
+        ORDER BY m.createdAt DESC LIMIT ?
+      `).all(safeQuery, limit);
+    }
+    return rows.map(this.rowToMessage);
+  }
+  // ── Quota ─────────────────────────────────────────────────
+  async getStorageSize() {
+    const db = this.ensureDb();
+    const pageSize = db.pragma("page_size", { simple: true }) ?? 4096;
+    const pageCount = db.pragma("page_count", { simple: true }) ?? 0;
+    const total = pageSize * pageCount;
+    const msgCount = db.prepare("SELECT COUNT(*) as cnt FROM messages").get()?.cnt ?? 0;
+    const convCount = db.prepare("SELECT COUNT(*) as cnt FROM conversations").get()?.cnt ?? 0;
+    const totalRecords = msgCount + convCount;
+    const msgRatio = totalRecords > 0 ? msgCount / totalRecords : 0.8;
+    return {
+      messages: Math.floor(total * msgRatio),
+      conversations: Math.floor(total * (1 - msgRatio)),
+      total
+    };
+  }
+  async clearOldMessages(conversationId, keepCount) {
+    const db = this.ensureDb();
+    const keepIds = db.prepare(
+      "SELECT id FROM messages WHERE conversationId = ? ORDER BY createdAt DESC LIMIT ?"
+    ).all(conversationId, keepCount).map((r) => r.id);
+    if (keepIds.length === 0) return 0;
+    const placeholders = keepIds.map(() => "?").join(",");
+    const result = db.prepare(
+      `DELETE FROM messages WHERE conversationId = ? AND id NOT IN (${placeholders})`
+    ).run(conversationId, ...keepIds);
+    db.prepare(
+      `DELETE FROM messages_fts WHERE conversationId = ? AND id NOT IN (${placeholders})`
+    ).run(conversationId, ...keepIds);
+    return result.changes;
+  }
+  // ── Lifecycle ───────────────────────────────────────────────
+  async clear() {
+    const db = this.ensureDb();
+    db.exec("DELETE FROM messages; DELETE FROM messages_fts; DELETE FROM conversations; DELETE FROM contacts; DELETE FROM cursors; DELETE FROM outbox;");
+  }
+  rowToOutbox(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      method: row.method,
+      path: row.path,
+      body: row.body ? JSON.parse(row.body) : void 0,
+      query: row.query ? JSON.parse(row.query) : void 0,
+      status: row.status,
+      createdAt: row.createdAt,
+      retries: row.retries ?? 0,
+      maxRetries: row.maxRetries ?? 5,
+      lastError: row.lastError ?? void 0,
+      idempotencyKey: row.idempotencyKey ?? "",
+      localData: row.localData ? JSON.parse(row.localData) : void 0
+    };
+  }
+};
+
+// src/multitab.ts
+var TabCoordinator = class {
+  constructor(offline, channelName = "prismer-tab-sync") {
+    this.offline = offline;
+    this.channelName = channelName;
+    this.channel = null;
+    this._isLeader = false;
+    this.disposed = false;
+    this.tabId = `tab-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  get isLeader() {
+    return this._isLeader;
+  }
+  /**
+   * Initialize tab coordination.
+   * Claims leadership immediately (last-login-wins).
+   */
+  init() {
+    if (typeof BroadcastChannel === "undefined") {
+      this._isLeader = true;
+      return;
+    }
+    this.channel = new BroadcastChannel(this.channelName);
+    this.channel.onmessage = (e) => this.handleMessage(e.data);
+    this.claimLeadership();
+  }
+  /**
+   * Release leadership and clean up.
+   */
+  destroy() {
+    this.disposed = true;
+    if (this.channel) {
+      if (this._isLeader) {
+        this.broadcast({ type: "tab.release", tabId: this.tabId });
+      }
+      this.channel.close();
+      this.channel = null;
+    }
+    this._isLeader = false;
+  }
+  /**
+   * Relay a sync event to passive tabs.
+   * Called by the leader tab after processing a sync event.
+   */
+  relaySyncEvent(event) {
+    if (this._isLeader && this.channel) {
+      this.broadcast({ type: "sync.event", tabId: this.tabId, payload: event });
+    }
+  }
+  // ── Private ──────────────────────────────────────────────────
+  claimLeadership() {
+    this._isLeader = true;
+    this.broadcast({ type: "tab.claim", tabId: this.tabId });
+    this.onBecomeLeader();
+  }
+  demoteToPassive() {
+    if (!this._isLeader) return;
+    this._isLeader = false;
+    this.onBecomePassive();
+  }
+  handleMessage(msg) {
+    if (this.disposed) return;
+    switch (msg.type) {
+      case "tab.claim": {
+        if (msg.tabId !== this.tabId) {
+          this.demoteToPassive();
+          this.broadcast({ type: "tab.ack", tabId: this.tabId });
+        }
+        break;
+      }
+      case "tab.release": {
+        if (!this._isLeader) {
+          this.claimLeadership();
+        }
+        break;
+      }
+      case "sync.event": {
+        if (!this._isLeader && msg.payload) {
+          this.offline["applySyncEvent"](msg.payload).catch(() => {
+          });
+        }
+        break;
+      }
+    }
+  }
+  onBecomeLeader() {
+  }
+  onBecomePassive() {
+    this.offline.stopContinuousSync();
+  }
+  broadcast(msg) {
+    try {
+      this.channel?.postMessage(msg);
+    } catch {
+    }
+  }
+};
+
+// src/encryption.ts
+function getSubtleCrypto() {
+  if (typeof globalThis.crypto?.subtle !== "undefined") {
+    return globalThis.crypto.subtle;
+  }
+  try {
+    const { webcrypto } = __require("crypto");
+    return webcrypto.subtle;
+  } catch {
+    throw new Error("No SubtleCrypto available. Requires browser or Node.js 16+.");
+  }
+}
+function getRandomValues(arr) {
+  if (typeof globalThis.crypto?.getRandomValues !== "undefined") {
+    return globalThis.crypto.getRandomValues(arr);
+  }
+  try {
+    const { webcrypto } = __require("crypto");
+    return webcrypto.getRandomValues(arr);
+  } catch {
+    throw new Error("No crypto.getRandomValues available.");
+  }
+}
+var subtle = () => getSubtleCrypto();
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+var KEY_LENGTH = 256;
+var _E2EEncryption = class _E2EEncryption {
+  constructor() {
+    this.masterKey = null;
+    this.keyPair = null;
+    this.sessionKeys = /* @__PURE__ */ new Map();
+    // conversationId → AES key
+    this.salt = null;
+    // ─── Pipeline Functions ──────────────────────────────────
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
+  }
+  /**
+   * Initialize encryption with user passphrase.
+   * Derives a master key via PBKDF2 and generates an ECDH key pair.
+   *
+   * @param passphrase - User passphrase for master key derivation
+   * @param salt - Optional Base64-encoded salt. If omitted, a random 16-byte salt is generated.
+   *               Store the salt (via exportSalt()) so you can re-derive the same master key later.
+   */
+  async init(passphrase, salt) {
+    this.salt = salt ? new Uint8Array(base64ToArrayBuffer(salt)) : getRandomValues(new Uint8Array(SALT_LENGTH));
+    const passphraseKey = await subtle().importKey(
+      "raw",
+      new TextEncoder().encode(passphrase),
+      "PBKDF2",
+      false,
+      ["deriveKey"]
+    );
+    this.masterKey = await subtle().deriveKey(
+      {
+        name: "PBKDF2",
+        salt: new Uint8Array(this.salt.buffer, this.salt.byteOffset, this.salt.byteLength).buffer,
+        iterations: PBKDF2_ITERATIONS,
+        hash: "SHA-256"
+      },
+      passphraseKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.keyPair = await subtle().generateKey(
+      { name: "ECDH", namedCurve: "P-256" },
+      true,
+      ["deriveKey"]
+    );
+  }
+  /**
+   * Export the salt as Base64 string for persistent storage.
+   * You must store this and pass it back to init() to re-derive the same master key.
+   */
+  exportSalt() {
+    if (!this.salt) throw new Error("E2E not initialized. Call init() first.");
+    return arrayBufferToBase64(this.salt.buffer);
+  }
+  /**
+   * Export public key for sharing with conversation peers.
+   */
+  async exportPublicKey() {
+    if (!this.keyPair) throw new Error("E2E not initialized. Call init() first.");
+    return subtle().exportKey("jwk", this.keyPair.publicKey);
+  }
+  /**
+   * Derive a shared session key for a conversation using ECDH.
+   * Call this with each peer's public key.
+   */
+  async deriveSessionKey(conversationId, peerPublicKey) {
+    if (!this.keyPair) throw new Error("E2E not initialized. Call init() first.");
+    const importedPeerKey = await subtle().importKey(
+      "jwk",
+      peerPublicKey,
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      []
+    );
+    const sessionKey = await subtle().deriveKey(
+      { name: "ECDH", public: importedPeerKey },
+      this.keyPair.privateKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, sessionKey);
+  }
+  /**
+   * Set a pre-shared session key for a conversation.
+   * Useful when the key is exchanged out-of-band or derived from a group key.
+   */
+  async setSessionKey(conversationId, rawKey) {
+    const key = await subtle().importKey(
+      "raw",
+      rawKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, key);
+  }
+  /**
+   * Generate a random session key for a conversation.
+   * Returns the raw key bytes for sharing with peers.
+   */
+  async generateSessionKey(conversationId) {
+    const key = await subtle().generateKey(
+      { name: "AES-GCM", length: KEY_LENGTH },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, key);
+    return subtle().exportKey("raw", key);
+  }
+  /**
+   * Encrypt plaintext for a conversation.
+   * Returns base64-encoded ciphertext with prepended IV.
+   */
+  async encrypt(conversationId, plaintext) {
+    const key = this.sessionKeys.get(conversationId);
+    if (!key) throw new Error(`No session key for conversation ${conversationId}. Call deriveSessionKey() first.`);
+    const iv = getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(plaintext);
+    const ciphertext = await subtle().encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv, 0);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return arrayBufferToBase64(combined.buffer);
+  }
+  /**
+   * Decrypt ciphertext from a conversation.
+   * Expects base64-encoded data with prepended IV.
+   */
+  async decrypt(conversationId, ciphertext) {
+    const key = this.sessionKeys.get(conversationId);
+    if (!key) throw new Error(`No session key for conversation ${conversationId}. Call deriveSessionKey() first.`);
+    const combined = base64ToArrayBuffer(ciphertext);
+    const iv = combined.slice(0, IV_LENGTH);
+    const data = combined.slice(IV_LENGTH);
+    const decrypted = await subtle().decrypt(
+      { name: "AES-GCM", iv: new Uint8Array(iv) },
+      key,
+      data
+    );
+    return new TextDecoder().decode(decrypted);
+  }
+  /**
+   * Check if a session key exists for a conversation.
+   */
+  hasSessionKey(conversationId) {
+    return this.sessionKeys.has(conversationId);
+  }
+  /**
+   * Remove session key for a conversation.
+   */
+  removeSessionKey(conversationId) {
+    this.sessionKeys.delete(conversationId);
+  }
+  /**
+   * Clear all keys and reset state.
+   */
+  destroy() {
+    this.masterKey = null;
+    this.keyPair = null;
+    this.sessionKeys.clear();
+    this.salt = null;
+    this.messageCount = 0;
+  }
+  /**
+   * High-level encrypt-for-send pipeline.
+   * Encrypts content, builds metadata, and handles key rotation.
+   *
+   * Returns { encryptedContent, metadata } ready to send.
+   */
+  async encryptForSend(conversationId, content) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    const needsRotation = this.shouldRotateKey();
+    const encryptedContent = await this.encrypt(conversationId, content);
+    this.messageCount++;
+    return {
+      encryptedContent,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        ...needsRotation && { keyRotationRequested: true }
+      }
+    };
+  }
+  /**
+   * High-level decrypt-on-receive pipeline.
+   * Decrypts content and validates metadata.
+   */
+  async decryptOnReceive(conversationId, encryptedContent, metadata) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    return this.decrypt(conversationId, encryptedContent);
+  }
+  /**
+   * High-level file encryption pipeline.
+   */
+  async encryptFile(conversationId, fileData) {
+    const base64Data = arrayBufferToBase64(fileData);
+    const encryptedData = await this.encrypt(conversationId, base64Data);
+    return {
+      encryptedData,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        fileEncrypted: true
+      }
+    };
+  }
+  /**
+   * High-level file decryption pipeline.
+   */
+  async decryptFile(conversationId, encryptedData) {
+    const base64Data = await this.decrypt(conversationId, encryptedData);
+    return base64ToArrayBuffer(base64Data);
+  }
+  /**
+   * Check if key rotation is needed (1000 messages or 24 hours).
+   */
+  shouldRotateKey() {
+    if (this.messageCount >= _E2EEncryption.KEY_ROTATION_THRESHOLD) {
+      return true;
+    }
+    if (Date.now() - this.lastRotation >= _E2EEncryption.KEY_ROTATION_INTERVAL_MS) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Perform key rotation: generate new ECDH keypair and reset counters.
+   * The caller is responsible for re-exchanging keys with peers.
+   */
+  async rotateKeys() {
+    this.keyPair = await subtle().generateKey(
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      ["deriveKey"]
+    );
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
+    this.sessionKeys.clear();
+    return this.exportPublicKey();
+  }
+};
+_E2EEncryption.KEY_ROTATION_THRESHOLD = 1e3;
+_E2EEncryption.KEY_ROTATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var E2EEncryption = _E2EEncryption;
+function arrayBufferToBase64(buffer) {
+  if (typeof btoa !== "undefined") {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function base64ToArrayBuffer(base64) {
+  if (typeof atob !== "undefined") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+  const buf = Buffer.from(base64, "base64");
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+// src/encryption-pipeline.ts
+async function encryptForSend(e2e, conversationId, content, metadata) {
+  if (!e2e.hasSessionKey(conversationId)) {
+    return { content, metadata: metadata ?? {} };
+  }
+  const ciphertext = await e2e.encrypt(conversationId, content);
+  return {
+    content: ciphertext,
+    metadata: { ...metadata, encrypted: true, encKeyId: `conv-${conversationId}` }
+  };
+}
+async function decryptOnReceive(e2e, conversationId, content, metadata) {
+  if (!metadata?.encrypted) {
+    return { content, decrypted: false };
+  }
+  if (!e2e.hasSessionKey(conversationId)) {
+    return { content, decrypted: false, error: "no_session_key" };
+  }
+  try {
+    const plain = await e2e.decrypt(conversationId, content);
+    return { content: plain, decrypted: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content, decrypted: false, error: message };
+  }
+}
+async function encryptFile(e2e, conversationId, data) {
+  if (!e2e.hasSessionKey(conversationId)) return null;
+  const b64 = typeof Buffer !== "undefined" ? Buffer.from(data).toString("base64") : uint8ArrayToBase64(data);
+  const ciphertext = await e2e.encrypt(conversationId, b64);
+  return {
+    data: ciphertext,
+    metadata: { encrypted: true, encKeyId: `conv-${conversationId}` }
+  };
+}
+async function decryptFile(e2e, conversationId, ciphertext) {
+  if (!e2e.hasSessionKey(conversationId)) return null;
+  try {
+    const b64 = await e2e.decrypt(conversationId, ciphertext);
+    if (typeof Buffer !== "undefined") {
+      return new Uint8Array(Buffer.from(b64, "base64"));
+    }
+    return base64ToUint8Array(b64);
+  } catch {
+    return null;
+  }
+}
+async function encryptContext(e2e, content, contextId = "context-cache") {
+  if (!e2e.hasSessionKey(contextId)) return null;
+  const ciphertext = await e2e.encrypt(contextId, content);
+  return { content: ciphertext, encrypted: true };
+}
+async function decryptContext(e2e, ciphertext, contextId = "context-cache") {
+  if (!e2e.hasSessionKey(contextId)) return null;
+  try {
+    return await e2e.decrypt(contextId, ciphertext);
+  } catch {
+    return null;
+  }
+}
+async function decryptMessages(e2e, messages, conversationId) {
+  let decryptedCount = 0;
+  const errors = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const convId = conversationId ?? msg.conversationId;
+    if (!convId) continue;
+    const result = await decryptOnReceive(e2e, convId, msg.content, msg.metadata);
+    if (result.decrypted) {
+      msg.content = result.content;
+      if (msg.metadata) {
+        msg.metadata._decrypted = true;
+      }
+      decryptedCount++;
+    } else if (result.error) {
+      errors.push({ index: i, error: result.error });
+    }
+  }
+  return { decryptedCount, errors };
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/evolution-cache.ts
+var EvolutionCache = class {
+  constructor() {
+    this._genes = /* @__PURE__ */ new Map();
+    this._edges = /* @__PURE__ */ new Map();
+    // key = signal_key
+    this._globalPrior = /* @__PURE__ */ new Map();
+    this._cursor = 0;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  get geneCount() {
+    return this._genes.size;
+  }
+  /** Load from a full snapshot */
+  loadSnapshot(snapshot) {
+    this._genes.clear();
+    this._edges.clear();
+    this._globalPrior.clear();
+    for (const gene of snapshot.genes) {
+      this._genes.set(gene.id, gene);
+    }
+    for (const edge of snapshot.edges) {
+      const list = this._edges.get(edge.signal_key) ?? [];
+      list.push(edge);
+      this._edges.set(edge.signal_key, list);
+    }
+    for (const [key, val] of Object.entries(snapshot.globalPrior)) {
+      this._globalPrior.set(key, val);
+    }
+    this._cursor = snapshot.cursor;
+  }
+  /** Apply incremental delta (alias: loadDelta) */
+  applyDelta(delta) {
+    const pulled = delta.pulled;
+    for (const gene of pulled.genes) {
+      this._genes.set(gene.id, gene);
+    }
+    for (const id of pulled.quarantines) {
+      this._genes.delete(id);
+    }
+    for (const edge of pulled.edges) {
+      const list = this._edges.get(edge.signal_key) ?? [];
+      const idx = list.findIndex((e) => e.gene_id === edge.gene_id);
+      if (idx >= 0) list[idx] = edge;
+      else list.push(edge);
+      this._edges.set(edge.signal_key, list);
+    }
+    for (const [key, val] of Object.entries(pulled.globalPrior)) {
+      this._globalPrior.set(key, val);
+    }
+    this._cursor = pulled.cursor;
+  }
+  /** Apply incremental delta (alias for applyDelta) */
+  loadDelta(delta) {
+    this.applyDelta(delta);
+  }
+  /** Select best gene locally using Thompson Sampling — pure CPU, <1ms */
+  selectGene(signals) {
+    if (this._genes.size === 0) {
+      return { action: "none", confidence: 0, reason: "no genes in cache", fromCache: true };
+    }
+    const signalKeys = signals.map((s) => s.type);
+    const candidates = [];
+    for (const gene of this._genes.values()) {
+      if (gene.visibility === "quarantined") continue;
+      const geneSignalTypes = (gene.signals_match || []).map(
+        (s) => typeof s === "string" ? s : s.type
+      );
+      if (geneSignalTypes.length === 0) continue;
+      const matchCount = signalKeys.filter((k) => geneSignalTypes.includes(k)).length;
+      const coverageScore = matchCount / geneSignalTypes.length;
+      if (coverageScore === 0) continue;
+      let alpha = gene.success_count + 1;
+      let beta = gene.failure_count + 1;
+      for (const key of signalKeys) {
+        const prior = this._globalPrior.get(key);
+        if (prior) {
+          alpha += 0.3 * prior.alpha;
+          beta += 0.3 * prior.beta;
+        }
+      }
+      const sampledScore = alpha / (alpha + beta);
+      const totalObs = gene.success_count + gene.failure_count;
+      if (totalObs >= 10 && gene.success_count / totalObs < 0.18) continue;
+      const rankScore = coverageScore * 0.4 + sampledScore * 0.6;
+      candidates.push({ gene, rankScore, coverageScore, sampledScore });
+    }
+    if (candidates.length === 0) {
+      return {
+        action: "create_suggested",
+        confidence: 0,
+        reason: "no matching genes for signals",
+        fromCache: true
+      };
+    }
+    candidates.sort((a, b) => b.rankScore - a.rankScore);
+    const best = candidates[0];
+    const alternatives = candidates.slice(1, 4).map((c) => ({
+      gene_id: c.gene.id,
+      confidence: Math.round(c.rankScore * 100) / 100,
+      title: c.gene.title
+    }));
+    return {
+      action: "apply_gene",
+      gene_id: best.gene.id,
+      gene: best.gene,
+      strategy: best.gene.strategy,
+      confidence: Math.round(best.rankScore * 100) / 100,
+      coverageScore: Math.round(best.coverageScore * 100) / 100,
+      alternatives,
+      reason: `local cache selection (${this._genes.size} genes)`,
+      fromCache: true
+    };
+  }
+};
+
+// src/signal-enrichment.ts
+var ERROR_PATTERNS = [
+  { pattern: /timeout|timed?\s*out|deadline\s*exceeded|context\s*deadline/i, type: "timeout" },
+  { pattern: /econnrefused|connection\s*refused/i, type: "connection_refused" },
+  { pattern: /enotfound|dns|getaddrinfo|resolve/i, type: "dns_error" },
+  { pattern: /rate\s*limit|too\s*many\s*requests|429/i, type: "rate_limit" },
+  { pattern: /401|unauthorized|unauthenticated|auth.*fail/i, type: "auth_error" },
+  { pattern: /403|forbidden|access\s*denied|permission/i, type: "permission_error" },
+  { pattern: /404|not\s*found/i, type: "not_found" },
+  { pattern: /5\d{2}|internal\s*server|server\s*error|502|503|504/i, type: "server_error" },
+  { pattern: /type\s*error|typeerror/i, type: "type_error" },
+  { pattern: /syntax\s*error|syntaxerror|unexpected\s*token/i, type: "syntax_error" },
+  { pattern: /reference\s*error|referenceerror|is\s*not\s*defined/i, type: "reference_error" },
+  { pattern: /out\s*of\s*memory|oom|heap|allocation\s*failed/i, type: "oom" },
+  { pattern: /crash|panic|segfault|sigsegv|sigabrt/i, type: "crash" },
+  { pattern: /quota|limit\s*exceeded|insufficient/i, type: "quota_exceeded" },
+  { pattern: /tls|ssl|certificate|cert\s*verify/i, type: "tls_error" },
+  { pattern: /deadlock|lock\s*timeout|lock\s*wait/i, type: "deadlock" }
+];
+function extractSignals(ctx) {
+  const tags = [];
+  if (ctx.error) {
+    let matched = false;
+    for (const { pattern, type } of ERROR_PATTERNS) {
+      if (pattern.test(ctx.error)) {
+        const tag = { type: `error:${type}` };
+        if (ctx.provider) tag.provider = ctx.provider;
+        if (ctx.stage) tag.stage = ctx.stage;
+        if (ctx.severity) tag.severity = ctx.severity;
+        tags.push(tag);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const normalized = ctx.error.slice(0, 50).toLowerCase().replace(/[^a-z0-9_]/g, "_");
+      const tag = { type: `error:${normalized}` };
+      if (ctx.provider) tag.provider = ctx.provider;
+      if (ctx.stage) tag.stage = ctx.stage;
+      tags.push(tag);
+    }
+  }
+  if (ctx.taskStatus === "failed") tags.push({ type: "task.failed" });
+  if (ctx.taskStatus === "completed") tags.push({ type: "task.completed" });
+  if (ctx.taskCapability) {
+    tags.push({ type: `capability:${ctx.taskCapability}` });
+  }
+  if (ctx.tags) {
+    for (const tag of ctx.tags) {
+      tags.push({ type: tag });
+    }
+  }
+  return tags;
+}
+function createEnrichedExtractor(config) {
+  if (config.mode === "rules") {
+    return async (ctx) => extractSignals(ctx);
+  }
+  const { llmExtract, timeoutMs = 3e3 } = config;
+  if (!llmExtract) return async (ctx) => extractSignals(ctx);
+  return async (ctx) => {
+    try {
+      const result = await Promise.race([
+        llmExtract(ctx),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("llm_timeout")), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch {
+      return extractSignals(ctx);
+    }
+  };
+}
+
+// src/evolution-runtime.ts
+var EvolutionRuntime = class {
+  constructor(client, config) {
+    this.client = client;
+    this.outbox = [];
+    this.started = false;
+    // Session tracking
+    this._sessions = [];
+    this._sessionCounter = 0;
+    this.config = {
+      syncIntervalMs: config?.syncIntervalMs ?? 6e4,
+      enrichment: config?.enrichment ?? { mode: "rules" },
+      scope: config?.scope ?? "global",
+      outboxMaxSize: config?.outboxMaxSize ?? 50,
+      outboxFlushMs: config?.outboxFlushMs ?? 5e3
+    };
+    this.scope = this.config.scope;
+    this.cache = new EvolutionCache();
+    this.enricher = config?.enrichment ? createEnrichedExtractor(config.enrichment) : async (ctx) => extractSignals(ctx);
+  }
+  // ─── Lifecycle ──────────────────────────────────────
+  /** Initialize: load snapshot + start sync + start outbox flush */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    try {
+      const snapshot = await this.client.getSyncSnapshot(0);
+      if (snapshot.data) {
+        this.cache.loadSnapshot(snapshot.data);
+      }
+    } catch {
+    }
+    if (this.config.syncIntervalMs > 0) {
+      this.syncTimer = setInterval(() => this.sync(), this.config.syncIntervalMs);
+    }
+    this.flushTimer = setInterval(() => this.flush(), this.config.outboxFlushMs);
+  }
+  /** Stop: clear timers + flush remaining outbox */
+  async stop() {
+    if (this.syncTimer) clearInterval(this.syncTimer);
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    await this.flush();
+    this.started = false;
+  }
+  // ─── High-Level API ─────────────────────────────────
+  /**
+   * Get a strategy recommendation for an error/context.
+   *
+   * Flow: extract signals → try local cache (<1ms) → fallback to server (~30ms)
+   *
+   * @param error - Error message or Error object
+   * @param context - Optional additional context (provider, stage, etc.)
+   */
+  async suggest(error, context) {
+    const errorStr = error instanceof Error ? error.message : error;
+    const ctx = {
+      error: errorStr,
+      ...context
+    };
+    const signals = await this.enricher(ctx);
+    if (signals.length === 0) {
+      return {
+        action: "none",
+        confidence: 0,
+        signals: [],
+        fromCache: false,
+        reason: "no signals extracted from error"
+      };
+    }
+    const buildSuggestion = (action, geneId, gene, strategy, confidence, fromCache, reason, alternatives) => {
+      this.lastSuggestedGeneId = geneId;
+      this._activeSession = {
+        id: `ses_${++this._sessionCounter}_${Date.now()}`,
+        suggestedAt: Date.now(),
+        suggestedGeneId: geneId,
+        signals,
+        adopted: false,
+        confidence,
+        fromCache
+      };
+      return {
+        action,
+        geneId,
+        gene,
+        strategy,
+        confidence,
+        signals,
+        fromCache,
+        reason,
+        alternatives
+      };
+    };
+    if (this.cache.geneCount > 0) {
+      const local = this.cache.selectGene(signals);
+      if (local.action === "apply_gene" && local.confidence > 0.3) {
+        return buildSuggestion(
+          local.action,
+          local.gene_id,
+          local.gene,
+          local.strategy,
+          local.confidence,
+          true,
+          local.reason,
+          local.alternatives
+        );
+      }
+    }
+    try {
+      const result = await this.client.analyze({
+        signals,
+        scope: this.scope
+      });
+      if (result.data) {
+        return buildSuggestion(
+          result.data.action,
+          result.data.gene_id,
+          result.data.gene,
+          result.data.strategy,
+          result.data.confidence ?? 0,
+          false,
+          result.data.reason,
+          result.data.alternatives
+        );
+      }
+    } catch {
+      const local = this.cache.selectGene(signals);
+      return buildSuggestion(
+        local.action,
+        local.gene_id,
+        local.gene,
+        local.strategy,
+        local.confidence,
+        true,
+        "server unreachable, using cache fallback",
+        local.alternatives
+      );
+    }
+    return {
+      action: "none",
+      confidence: 0,
+      signals,
+      fromCache: false,
+      reason: "no recommendation from server"
+    };
+  }
+  /**
+   * Record an outcome. Fire-and-forget — never blocks, never throws.
+   *
+   * @param error - The error that was encountered
+   * @param outcome - 'success' or 'failed'
+   * @param summary - One-line summary of what happened
+   * @param geneId - Gene that was used (auto-detected from last suggest() if omitted)
+   */
+  learned(error, outcome, summary, geneId, metadata) {
+    const errorStr = error instanceof Error ? error.message : error;
+    const ctx = { error: errorStr };
+    const signals = extractSignals(ctx);
+    const resolvedGeneId = geneId || this.lastSuggestedGeneId;
+    if (!resolvedGeneId) return;
+    if (this._activeSession) {
+      const session = this._activeSession;
+      session.usedGeneId = resolvedGeneId;
+      session.adopted = resolvedGeneId === session.suggestedGeneId;
+      session.completedAt = Date.now();
+      session.outcome = outcome;
+      session.durationMs = session.completedAt - session.suggestedAt;
+      this._sessions.push(session);
+      this._activeSession = void 0;
+    }
+    this.outbox.push({
+      geneId: resolvedGeneId,
+      signals,
+      outcome,
+      summary,
+      metadata,
+      timestamp: Date.now(),
+      sessionId: this._sessions[this._sessions.length - 1]?.id
+    });
+    if (this.outbox.length >= this.config.outboxMaxSize) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  // ─── Session Metrics ────────────────────────────────
+  /** Get all completed sessions. */
+  get sessions() {
+    return this._sessions;
+  }
+  /** Get aggregate metrics for benchmarking. */
+  getMetrics() {
+    const sessions = this._sessions;
+    const totalSuggestions = sessions.length;
+    const suggestionsWithGene = sessions.filter((s) => s.suggestedGeneId).length;
+    const totalLearned = sessions.filter((s) => s.completedAt).length;
+    const adoptedSessions = sessions.filter((s) => s.adopted && s.completedAt);
+    const adoptedCount = adoptedSessions.length;
+    const nonAdopted = sessions.filter((s) => !s.adopted && s.completedAt);
+    const durations = sessions.filter((s) => s.durationMs != null).map((s) => s.durationMs);
+    const avgDurationMs = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+    const adoptedSuccess = adoptedSessions.filter((s) => s.outcome === "success").length;
+    const nonAdoptedSuccess = nonAdopted.filter((s) => s.outcome === "success").length;
+    const cacheHits = sessions.filter((s) => s.fromCache).length;
+    return {
+      totalSuggestions,
+      suggestionsWithGene,
+      totalLearned,
+      adoptedCount,
+      geneUtilizationRate: suggestionsWithGene > 0 ? Math.round(adoptedCount / suggestionsWithGene * 100) / 100 : 0,
+      avgDurationMs,
+      adoptedSuccessRate: adoptedCount > 0 ? Math.round(adoptedSuccess / adoptedCount * 100) / 100 : 0,
+      nonAdoptedSuccessRate: nonAdopted.length > 0 ? Math.round(nonAdoptedSuccess / nonAdopted.length * 100) / 100 : 0,
+      cacheHitRate: totalSuggestions > 0 ? Math.round(cacheHits / totalSuggestions * 100) / 100 : 0
+    };
+  }
+  /** Reset session history. */
+  resetMetrics() {
+    this._sessions = [];
+  }
+  // ─── Internal ───────────────────────────────────────
+  /** Sync cache with server */
+  async sync() {
+    try {
+      const result = await this.client.sync({
+        pull: { since: this.cache.cursor },
+        scope: this.scope
+      });
+      if (result.data?.pulled) {
+        this.cache.applyDelta({ pulled: result.data.pulled });
+      }
+    } catch {
+    }
+  }
+  /** Flush outbox to server */
+  async flush() {
+    if (this.outbox.length === 0) return;
+    const batch = this.outbox.splice(0, this.config.outboxMaxSize);
+    const promises = batch.map(
+      (entry) => this.client.record({
+        gene_id: entry.geneId,
+        signals: entry.signals.map((s) => s.type),
+        outcome: entry.outcome,
+        summary: entry.summary,
+        score: entry.score,
+        metadata: entry.metadata,
+        scope: this.scope
+      }).catch(() => {
+        this.outbox.push(entry);
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+};
+
+// src/index.ts
+var _fs = null;
+var _os = null;
+var _path = null;
+try {
+  _fs = __require("fs");
+  _os = __require("os");
+  _path = __require("path");
+} catch {
+}
+function resolveApiKey(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_API_KEY) {
+      return process.env.PRISMER_API_KEY;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^api_key\s*=\s*'([^']+)'/m) || raw.match(/^api_key\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return "";
+}
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_BASE_URL) {
+      return process.env.PRISMER_BASE_URL;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^base_url\s*=\s*'([^']+)'/m) || raw.match(/^base_url\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return void 0;
+}
+var AccountClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Register an agent or human identity */
+  async register(options) {
+    return this._r("POST", "/api/im/register", options);
+  }
+  /** Get own identity, stats, bindings, credits */
+  async me() {
+    return this._r("GET", "/api/im/me");
+  }
+  /** Update own profile */
+  async updateProfile(options) {
+    return this._r("PATCH", "/api/im/me", options);
+  }
+  /** Refresh JWT token */
+  async refreshToken() {
+    return this._r("POST", "/api/im/token/refresh");
+  }
+};
+var DirectClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Send a direct message to a user */
+  async send(userId, content, options) {
+    return this._r("POST", `/api/im/direct/${userId}/messages`, {
+      content,
+      type: options?.type ?? "text",
+      metadata: options?.metadata,
+      parentId: options?.parentId,
+      quotedMessageId: options?.quotedMessageId
+    });
+  }
+  /** Get direct message history with a user */
+  async getMessages(userId, options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.offset != null) query.offset = String(options.offset);
+    return this._r("GET", `/api/im/direct/${userId}/messages`, void 0, query);
+  }
+};
+var GroupsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a group chat */
+  async create(options) {
+    return this._r("POST", "/api/im/groups", options);
+  }
+  /** List groups you belong to */
+  async list() {
+    return this._r("GET", "/api/im/groups");
+  }
+  /** Get group details */
+  async get(groupId) {
+    return this._r("GET", `/api/im/groups/${groupId}`);
+  }
+  /** Send a message to a group */
+  async send(groupId, content, options) {
+    return this._r("POST", `/api/im/groups/${groupId}/messages`, {
+      content,
+      type: options?.type ?? "text",
+      metadata: options?.metadata,
+      parentId: options?.parentId,
+      quotedMessageId: options?.quotedMessageId
+    });
+  }
+  /** Get group message history */
+  async getMessages(groupId, options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.offset != null) query.offset = String(options.offset);
+    return this._r("GET", `/api/im/groups/${groupId}/messages`, void 0, query);
+  }
+  /** Add a member to a group (owner/admin only) */
+  async addMember(groupId, userId) {
+    return this._r("POST", `/api/im/groups/${groupId}/members`, { userId });
+  }
+  /** Remove a member from a group (owner/admin only) */
+  async removeMember(groupId, userId) {
+    return this._r("DELETE", `/api/im/groups/${groupId}/members/${userId}`);
+  }
+};
+var ConversationsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List conversations */
+  async list(options) {
+    const query = {};
+    if (options?.withUnread) query.withUnread = "true";
+    if (options?.unreadOnly) query.unreadOnly = "true";
+    return this._r("GET", "/api/im/conversations", void 0, query);
+  }
+  /** Get conversation details */
+  async get(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}`);
+  }
+  /** Create a direct conversation */
+  async createDirect(userId) {
+    return this._r("POST", "/api/im/conversations/direct", { userId });
+  }
+  /** Mark a conversation as read */
+  async markAsRead(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/read`);
+  }
+  /** Archive a conversation */
+  async archive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/archive`);
+  }
+  /** Unarchive a conversation */
+  async unarchive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/unarchive`);
+  }
+  /** Update conversation metadata */
+  async update(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}`, options);
+  }
+  /** Pin or unpin a conversation */
+  async pin(conversationId, pinned) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/pin`, { pinned });
+  }
+  /** Mute or unmute a conversation */
+  async mute(conversationId, muted) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/mute`, { muted });
+  }
+  /** Delete a conversation */
+  async delete(conversationId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}`);
+  }
+};
+var MessagesClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Send a message to a conversation */
+  async send(conversationId, content, options) {
+    return this._r("POST", `/api/im/messages/${conversationId}`, {
+      content,
+      type: options?.type ?? "text",
+      metadata: options?.metadata,
+      parentId: options?.parentId,
+      quotedMessageId: options?.quotedMessageId
+    });
+  }
+  /** Get message history for a conversation */
+  async getHistory(conversationId, options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.offset != null) query.offset = String(options.offset);
+    return this._r("GET", `/api/im/messages/${conversationId}`, void 0, query);
+  }
+  /** Edit a message */
+  async edit(conversationId, messageId, content, options) {
+    return this._r("PATCH", `/api/im/messages/${conversationId}/${messageId}`, { content, ...options?.metadata ? { metadata: options.metadata } : {} });
+  }
+  /** Delete a message */
+  async delete(conversationId, messageId) {
+    return this._r("DELETE", `/api/im/messages/${conversationId}/${messageId}`);
+  }
+  /** Mark messages as delivered */
+  async markDelivered(conversationId, messageIds) {
+    return this._r("POST", "/api/im/messages/delivered", { conversationId, messageIds });
+  }
+  /**
+   * Add or remove an emoji reaction on a message (v1.8.2).
+   * Idempotent — adding an existing reaction or removing a non-existent one is a no-op.
+   * Returns the full reactions snapshot: `{ "👍": ["userId-a", ...], ... }`.
+   */
+  async react(conversationId, messageId, emoji, options) {
+    return this._r("POST", `/api/im/messages/${conversationId}/${messageId}/reactions`, {
+      emoji,
+      ...options?.remove ? { remove: true } : {}
+    });
+  }
+};
+var ContactsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List contacts (users you've communicated with) */
+  async list() {
+    return this._r("GET", "/api/im/contacts");
+  }
+  /** Search users/agents by query */
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.type && options.type !== "all") params.type = options.type;
+    if (options?.limit) params.limit = String(options.limit);
+    if (options?.offset) params.offset = String(options.offset);
+    return this._r("GET", "/api/im/discover", void 0, params);
+  }
+  /** Get a user's public profile */
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/users/${userId}`);
+  }
+  /** Discover agents by capability or type */
+  async discover(options) {
+    const query = {};
+    if (options?.type) query.type = options.type;
+    if (options?.capability) query.capability = options.capability;
+    return this._r("GET", "/api/im/discover", void 0, query);
+  }
+  // ─── Friend System (v1.8.0 P9) ─────────────────────────
+  /** Send a friend request */
+  async request(userId, opts) {
+    return this._r("POST", "/api/im/contacts/request", { userId, ...opts });
+  }
+  /** List pending friend requests received */
+  async pendingReceived(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/received", void 0, params);
+  }
+  /** List pending friend requests sent */
+  async pendingSent(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/sent", void 0, params);
+  }
+  /** Accept a friend request */
+  async accept(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/accept`);
+  }
+  /** Reject a friend request */
+  async reject(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/reject`);
+  }
+  /** List friends */
+  async friends(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/friends", void 0, params);
+  }
+  /** Remove a friend */
+  async remove(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/remove`);
+  }
+  /** Set a remark/alias for a contact */
+  async setRemark(userId, remark) {
+    return this._r("PATCH", `/api/im/contacts/${userId}/remark`, { remark });
+  }
+  /** Block a user */
+  async block(userId) {
+    return this._r("POST", `/api/im/contacts/${userId}/block`, {});
+  }
+  /** Unblock a user */
+  async unblock(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/block`);
+  }
+  /** List blocked users */
+  async blocklist(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/blocked", void 0, params);
+  }
+  /** Get presence status for multiple users */
+  async getPresence(userIds) {
+    return this._r("POST", "/api/im/presence/batch", { userIds });
+  }
+};
+var BindingsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a social binding */
+  async create(options) {
+    return this._r("POST", "/api/im/bindings", options);
+  }
+  /** Verify a binding with 6-digit code */
+  async verify(bindingId, code) {
+    return this._r("POST", `/api/im/bindings/${bindingId}/verify`, { code });
+  }
+  /** List bindings */
+  async list() {
+    return this._r("GET", "/api/im/bindings");
+  }
+  /** Delete a binding */
+  async delete(bindingId) {
+    return this._r("DELETE", `/api/im/bindings/${bindingId}`);
+  }
+};
+var CreditsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get credits balance */
+  async get() {
+    return this._r("GET", "/api/im/credits");
+  }
+  /** Get credit transaction history */
+  async transactions(options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.offset != null) query.offset = String(options.offset);
+    return this._r("GET", "/api/im/credits/transactions", void 0, query);
+  }
+};
+var WorkspaceClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Initialize a 1:1 workspace (1 user + 1 agent) */
+  async init(options) {
+    return this._r("POST", "/api/im/workspace/init", options);
+  }
+  /** Initialize a group workspace (multi-user + multi-agent) */
+  async initGroup(options) {
+    return this._r("POST", "/api/im/workspace/init-group", options);
+  }
+  /** Add an agent to a workspace */
+  async addAgent(workspaceId, agentId) {
+    return this._r("POST", `/api/im/workspace/${workspaceId}/agents`, { agentId });
+  }
+  /** List agents in a workspace */
+  async listAgents(workspaceId) {
+    return this._r("GET", `/api/im/workspace/${workspaceId}/agents`);
+  }
+  /** @mention autocomplete */
+  async mentionAutocomplete(conversationId, query) {
+    const q = { conversationId };
+    if (query) q.q = query;
+    return this._r("GET", "/api/im/workspace/mentions/autocomplete", void 0, q);
+  }
+};
+var TasksClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a new task */
+  async create(options) {
+    return this._r("POST", "/api/im/tasks", options);
+  }
+  /** List tasks with optional filters */
+  async list(options) {
+    const query = {};
+    if (options?.status) query.status = options.status;
+    if (options?.capability) query.capability = options.capability;
+    if (options?.assigneeId) query.assigneeId = options.assigneeId;
+    if (options?.creatorId) query.creatorId = options.creatorId;
+    if (options?.scheduleType) query.scheduleType = options.scheduleType;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.cursor) query.cursor = options.cursor;
+    return this._r("GET", "/api/im/tasks", void 0, query);
+  }
+  /** Get task details with logs */
+  async get(taskId) {
+    return this._r("GET", `/api/im/tasks/${taskId}`);
+  }
+  /** Update a task */
+  async update(taskId, options) {
+    return this._r("PATCH", `/api/im/tasks/${taskId}`, options);
+  }
+  /** Claim a pending task */
+  async claim(taskId) {
+    return this._r("POST", `/api/im/tasks/${taskId}/claim`);
+  }
+  /** Report progress on a task */
+  async progress(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/progress`, options);
+  }
+  /** Complete a task with result */
+  async complete(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/complete`, options);
+  }
+  /** Fail a task with error */
+  async fail(taskId, error, metadata) {
+    return this._r("POST", `/api/im/tasks/${taskId}/fail`, { error, metadata });
+  }
+  /** Approve a completed task */
+  async approve(taskId) {
+    return this._r("POST", `/api/im/tasks/${taskId}/approve`);
+  }
+  /** Reject a task with reason */
+  async reject(taskId, reason) {
+    return this._r("POST", `/api/im/tasks/${taskId}/reject`, { reason });
+  }
+  /** Cancel a task */
+  async cancel(taskId) {
+    return this._r("DELETE", `/api/im/tasks/${taskId}`);
+  }
+};
+var MemoryClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a memory file */
+  async createFile(options) {
+    return this._r("POST", "/api/im/memory/files", options);
+  }
+  /** List memory files */
+  async listFiles(options) {
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    if (options?.path) query.path = options.path;
+    return this._r("GET", "/api/im/memory/files", void 0, query);
+  }
+  /** Get a memory file by ID */
+  async getFile(fileId) {
+    return this._r("GET", `/api/im/memory/files/${fileId}`);
+  }
+  /** Update a memory file (append, replace, or replace_section) */
+  async updateFile(fileId, options) {
+    return this._r("PATCH", `/api/im/memory/files/${fileId}`, options);
+  }
+  /** Delete a memory file */
+  async deleteFile(fileId) {
+    return this._r("DELETE", `/api/im/memory/files/${fileId}`);
+  }
+  /** Compact conversation messages into a summary */
+  async compact(options) {
+    return this._r("POST", "/api/im/memory/compact", options);
+  }
+  /** Get compaction summaries for a conversation */
+  async getCompaction(conversationId) {
+    return this._r("GET", `/api/im/memory/compact/${conversationId}`);
+  }
+  /** Load memory for session context */
+  async load(scope) {
+    const query = {};
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/memory/load", void 0, query);
+  }
+  /** Get memory-gene knowledge links for the authenticated user's memory files (v1.8.0) */
+  async getKnowledgeLinks() {
+    return this._r("GET", "/api/im/memory/links");
+  }
+};
+var KnowledgeLinkClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /**
+   * Get all knowledge links for a given entity.
+   * @param entityType - One of: memory, gene, capsule, signal
+   * @param entityId   - The entity ID
+   */
+  async getLinks(entityType, entityId) {
+    return this._r("GET", "/api/im/knowledge/links", void 0, { entityType, entityId });
+  }
+};
+var IdentityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get server public key */
+  async getServerKey() {
+    return this._r("GET", "/api/im/keys/server");
+  }
+  /** Register or rotate an identity key */
+  async registerKey(options) {
+    return this._r("PUT", "/api/im/keys/identity", options);
+  }
+  /** Get a user's identity key */
+  async getKey(userId) {
+    return this._r("GET", `/api/im/keys/identity/${userId}`);
+  }
+  /** Revoke own identity key */
+  async revokeKey() {
+    return this._r("POST", "/api/im/keys/identity/revoke");
+  }
+  /** Get key audit log for a user */
+  async getAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}`);
+  }
+  /** Verify key audit log integrity */
+  async verifyAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}/verify`);
+  }
+};
+var SecurityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get conversation security settings */
+  async getConversationSecurity(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/security`);
+  }
+  /** Update conversation security settings */
+  async setConversationSecurity(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/security`, options);
+  }
+  /** Upload a public key for a conversation */
+  async uploadKey(conversationId, publicKey, algorithm) {
+    const body = { publicKey };
+    if (algorithm) body.algorithm = algorithm;
+    return this._r("POST", `/api/im/conversations/${conversationId}/keys`, body);
+  }
+  /** Get keys for a conversation */
+  async getKeys(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/keys`);
+  }
+  /** Revoke a key for a specific user in a conversation */
+  async revokeKey(conversationId, keyUserId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}/keys/${keyUserId}`);
+  }
+};
+var EvolutionClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  // ── Public endpoints (no auth required) ──
+  /** Get evolution stats */
+  async getStats() {
+    return this._r("GET", "/api/im/evolution/public/stats");
+  }
+  /** Get hot/trending genes */
+  async getHotGenes(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/hot", void 0, query);
+  }
+  /** Browse published genes */
+  async browseGenes(options) {
+    const query = {};
+    if (options?.category) query.category = options.category;
+    if (options?.search) query.search = options.search;
+    if (options?.sort) query.sort = options.sort;
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/im/evolution/public/genes", void 0, query);
+  }
+  /** Get a public gene by ID */
+  async getPublicGene(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}`);
+  }
+  /** Get capsules for a public gene */
+  async getGeneCapsules(geneId, limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/capsules`, void 0, query);
+  }
+  /** Get gene lineage (parent + children) */
+  async getGeneLineage(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/lineage`);
+  }
+  /** Get public evolution feed */
+  async getFeed(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
+  }
+  // ── Leaderboard V2 (public, no auth required) ──
+  /** Get hero section global stats (total agents, genes, capsules, savings) */
+  async getLeaderboardHero() {
+    return this._r("GET", "/api/im/evolution/leaderboard/hero");
+  }
+  /** Get rising stars leaderboard */
+  async getLeaderboardRising(period, limit) {
+    const query = {};
+    if (period) query.period = period;
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/leaderboard/rising", void 0, query);
+  }
+  /** Get leaderboard summary stats (totalAgentsEvolving, totalGenesCreated, etc.) */
+  async getLeaderboardStats() {
+    return this._r("GET", "/api/im/evolution/leaderboard/stats");
+  }
+  /** Get agent improvement board */
+  async getLeaderboardAgents(period, domain) {
+    const query = {};
+    if (period) query.period = period;
+    if (domain) query.domain = domain;
+    return this._r("GET", "/api/im/evolution/leaderboard/agents", void 0, query);
+  }
+  /** Get gene impact board */
+  async getLeaderboardGenes(period, sort) {
+    const query = {};
+    if (period) query.period = period;
+    if (sort) query.sort = sort;
+    return this._r("GET", "/api/im/evolution/leaderboard/genes", void 0, query);
+  }
+  /** Get contributor board */
+  async getLeaderboardContributors(period) {
+    const query = {};
+    if (period) query.period = period;
+    return this._r("GET", "/api/im/evolution/leaderboard/contributors", void 0, query);
+  }
+  /** Get cross-environment comparison data */
+  async getLeaderboardComparison() {
+    return this._r("GET", "/api/im/evolution/leaderboard/comparison");
+  }
+  /** Get public profile page data for an agent or owner */
+  async getPublicProfile(entityId) {
+    return this._r("GET", `/api/im/evolution/profile/${encodeURIComponent(entityId)}`);
+  }
+  /** Render agent/creator card as PNG */
+  async renderCard(input) {
+    return this._r("POST", "/api/im/evolution/card/render", input);
+  }
+  /** Get benchmark data for profile FOMO section */
+  async getBenchmark() {
+    return this._r("GET", "/api/im/evolution/benchmark");
+  }
+  /** Get gene highlight capsules for profile page */
+  async getHighlights(geneId) {
+    return this._r("GET", `/api/im/evolution/highlights/${encodeURIComponent(geneId)}`);
+  }
+  // ── Authenticated endpoints ──
+  /** Analyze signals and get gene recommendation */
+  async analyze(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/analyze", body, q);
+  }
+  /** Record an outcome (success/failure) for a gene */
+  async record(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/record", body, q);
+  }
+  /**
+   * One-step evolution: analyze context → get gene recommendation → auto-record outcome.
+   * Combines analyze() + record() into a single call for the common case.
+   *
+   * Usage:
+   *   const result = await client.evolution.evolve({
+   *     error: 'Connection timeout after 10s',
+   *     outcome: 'success',
+   *     score: 0.85,
+   *     summary: 'Fixed with exponential backoff',
+   *   });
+   */
+  async evolve(options) {
+    const { outcome, score, summary, strategy_used, scope, ...analyzeOpts } = options;
+    const analysis = await this.analyze({ ...analyzeOpts, ...scope ? { scope } : {} });
+    if (!analysis.ok || !analysis.data) {
+      return { ok: false, error: analysis.error };
+    }
+    const data = analysis.data;
+    const geneId = data.gene_id;
+    if (geneId && (data.action === "apply_gene" || data.action === "explore")) {
+      const recordResult = await this.record({
+        gene_id: geneId,
+        signals: data.signals || analyzeOpts.signals || [],
+        outcome,
+        score: score ?? (outcome === "success" ? 0.8 : 0.2),
+        summary: summary || `${outcome === "success" ? "Resolved" : "Failed to resolve"} using ${geneId}`,
+        strategy_used,
+        ...scope ? { scope } : {}
+      });
+      return {
+        ok: true,
+        data: {
+          analysis: data,
+          recorded: true,
+          edge_updated: recordResult.data?.edge_updated
+        }
+      };
+    }
+    return {
+      ok: true,
+      data: { analysis: data, recorded: false }
+    };
+  }
+  /** Trigger gene distillation */
+  async distill(dryRun) {
+    const query = {};
+    if (dryRun) query.dry_run = "true";
+    return this._r("POST", "/api/im/evolution/distill", void 0, query);
+  }
+  /** List own genes */
+  async listGenes(signals, scope) {
+    const query = {};
+    if (signals) query.signals = signals;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/genes", void 0, query);
+  }
+  /** Create a new gene */
+  async createGene(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/genes", body, q);
+  }
+  /** Delete a gene */
+  async deleteGene(geneId) {
+    return this._r("DELETE", `/api/im/evolution/genes/${encodeURIComponent(geneId)}`);
+  }
+  /** Publish a gene. Pass skipCanary=true to bypass canary validation (MVP/admin). */
+  async publishGene(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${encodeURIComponent(geneId)}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
+  }
+  /** Import a published gene */
+  async importGene(geneId) {
+    return this._r("POST", "/api/im/evolution/genes/import", { gene_id: geneId });
+  }
+  /** Fork a gene with modifications */
+  async forkGene(options) {
+    return this._r("POST", "/api/im/evolution/genes/fork", options);
+  }
+  /** Get signal-gene edges */
+  async getEdges(options) {
+    const query = {};
+    if (options?.signalKey) query.signal_key = options.signalKey;
+    if (options?.geneId) query.gene_id = options.geneId;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/edges", void 0, query);
+  }
+  /** Get agent personality profile */
+  async getPersonality(agentId) {
+    return this._r("GET", `/api/im/evolution/personality/${agentId}`);
+  }
+  /** Get own capsule history */
+  async getCapsules(options) {
+    const query = {};
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/capsules", void 0, query);
+  }
+  /** Get evolution report */
+  async getReport(agentId, scope) {
+    const query = {};
+    if (agentId) query.agent_id = agentId;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/report", void 0, query);
+  }
+  /** List available evolution scopes */
+  async listScopes() {
+    return this._r("GET", "/api/im/evolution/scopes");
+  }
+  // ─── v0.3.1: Stories, Metrics, Skills ──────────────
+  /** Get recent evolution stories (for L1 narrative embedding) */
+  async getStories(options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.since != null) query.since = String(options.since);
+    return this._r("GET", "/api/im/evolution/stories", void 0, query);
+  }
+  /** Get north-star metrics comparison (standard vs hypergraph) */
+  async getMetrics() {
+    return this._r("GET", "/api/im/evolution/metrics");
+  }
+  /** Trigger metrics collection snapshot */
+  async collectMetrics(windowHours) {
+    return this._r("POST", "/api/im/evolution/metrics/collect", { window_hours: windowHours ?? 1 });
+  }
+  /** Search skills catalog */
+  async searchSkills(options) {
+    const q = {};
+    if (options?.query) q.query = options.query;
+    if (options?.category) q.category = options.category;
+    if (options?.limit != null) q.limit = String(options.limit);
+    return this._r("GET", "/api/im/skills/search", void 0, q);
+  }
+  /** Get skill catalog stats */
+  async getSkillStats() {
+    return this._r("GET", "/api/im/skills/stats");
+  }
+  /** Install a skill — creates Gene + returns content + install guide */
+  async installSkill(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
+  }
+  /** Uninstall a skill */
+  async uninstallSkill(slugOrId) {
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  }
+  /** List installed skills for this agent */
+  async installedSkills() {
+    return this._r("GET", "/api/im/skills/installed");
+  }
+  /** Get full skill content (SKILL.md + package info) */
+  async getSkillContent(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+  }
+  /** Create/submit a community skill */
+  async createSkill(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Star a skill (increment community rating) */
+  async starSkill(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
+  /**
+   * Install a skill and write SKILL.md to local filesystem.
+   * Combines cloud install + local file sync for Claude Code / OpenClaw / OpenCode.
+   * @param slugOrId - Skill slug or ID
+   * @param options - Local install options
+   */
+  async installSkillLocal(slugOrId, options) {
+    const result = await this.installSkill(slugOrId);
+    if (!result.ok || !result.data) return result;
+    let content = result.data.skill?.content || "";
+    if (!content) {
+      const contentResult = await this.getSkillContent(slugOrId);
+      content = contentResult.data?.content || "";
+    }
+    if (!content) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const rawSlug = result.data.skill?.slug || slugOrId;
+    const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+    if (!slug) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const localPaths = [];
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+      const home = os.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+      const platformPaths = options?.project ? {
+        "claude-code": path.join(options.projectRoot || ".", ".claude", "skills", slug),
+        "openclaw": path.join(options.projectRoot || ".", "skills", slug),
+        "opencode": path.join(options.projectRoot || ".", ".opencode", "skills", slug),
+        "plugin": path.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
+      } : {
+        "claude-code": path.join(home, ".claude", "skills", slug),
+        "openclaw": path.join(home, ".openclaw", "skills", slug),
+        "opencode": path.join(home, ".config", "opencode", "skills", slug),
+        "plugin": path.join(pluginBase, "skills", slug)
+      };
+      const targets = options?.platforms || Object.keys(platformPaths);
+      for (const platform of targets) {
+        const dir = platformPaths[platform];
+        if (!dir) continue;
+        try {
+          fs.mkdirSync(dir, { recursive: true });
+          const filePath = path.join(dir, "SKILL.md");
+          fs.writeFileSync(filePath, content, "utf-8");
+          localPaths.push(filePath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { ...result.data, localPaths } };
+  }
+  /**
+   * Uninstall a skill and remove local SKILL.md files.
+   */
+  async uninstallSkillLocal(slugOrId) {
+    const result = await this.uninstallSkill(slugOrId);
+    const removedPaths = [];
+    const slug = safeSlug(slugOrId);
+    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+      const home = os.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+      const dirs = [
+        path.join(home, ".claude", "skills", slug),
+        path.join(home, ".openclaw", "skills", slug),
+        path.join(home, ".config", "opencode", "skills", slug),
+        path.join(pluginBase, "skills", slug)
+      ];
+      for (const dir of dirs) {
+        try {
+          if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true });
+            removedPaths.push(dir);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+  }
+  /**
+   * Sync all installed skills to local filesystem.
+   */
+  async syncSkillsLocal(options) {
+    const installed = await this.installedSkills();
+    if (!installed.ok || !installed.data) return { synced: 0, failed: 0, paths: [] };
+    let synced = 0;
+    let failed = 0;
+    const paths = [];
+    for (const record of installed.data) {
+      const rawSlug = record.skill?.slug;
+      if (!rawSlug) {
+        failed++;
+        continue;
+      }
+      const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+      if (!slug) {
+        failed++;
+        continue;
+      }
+      try {
+        const contentResult = await this.getSkillContent(slug);
+        const content = contentResult.data?.content;
+        if (!content) {
+          failed++;
+          continue;
+        }
+        const fs = await import("fs");
+        const path = await import("path");
+        const os = await import("os");
+        const home = os.homedir();
+        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+        const platformPaths = {
+          "claude-code": path.join(home, ".claude", "skills", slug),
+          "openclaw": path.join(home, ".openclaw", "skills", slug),
+          "opencode": path.join(home, ".config", "opencode", "skills", slug),
+          "plugin": path.join(pluginBase, "skills", slug)
+        };
+        const targets = options?.platforms || Object.keys(platformPaths);
+        for (const platform of targets) {
+          const dir = platformPaths[platform];
+          if (!dir) continue;
+          try {
+            fs.mkdirSync(dir, { recursive: true });
+            const filePath = path.join(dir, "SKILL.md");
+            fs.writeFileSync(filePath, content, "utf-8");
+            paths.push(filePath);
+          } catch {
+          }
+        }
+        synced++;
+      } catch {
+        failed++;
+      }
+    }
+    return { synced, failed, paths };
+  }
+  /** Export a Gene as a Skill */
+  async exportAsSkill(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${geneId}/export-skill`, options);
+  }
+  // ─── P0: Report, Achievements, Sync ──────────────
+  /** Submit a raw-context evolution report (auto-creates signals + gene match) */
+  async submitReport(options) {
+    return this._r("POST", "/api/im/evolution/report", {
+      raw_context: options.rawContext,
+      outcome: options.outcome,
+      task_context: options.taskContext,
+      task_error: options.taskError,
+      task_id: options.taskId,
+      metadata: options.metadata
+    });
+  }
+  /** Get status of a submitted report by traceId */
+  async getReportStatus(traceId) {
+    return this._r("GET", `/api/im/evolution/report/${traceId}`);
+  }
+  /** Get evolution achievements for the current agent */
+  async getAchievements() {
+    return this._r("GET", "/api/im/evolution/achievements");
+  }
+  /** Get a sync snapshot (global gene/edge state since a sequence number) */
+  async getSyncSnapshot(since) {
+    const query = { scope: "global" };
+    if (since != null) query.since = String(since);
+    return this._r("GET", "/api/im/evolution/sync/snapshot", void 0, query);
+  }
+  /** Bidirectional sync: push local outcomes and pull remote updates */
+  async sync(options) {
+    const body = {};
+    if (options?.pushOutcomes) body.push = { outcomes: options.pushOutcomes };
+    if (options?.pullSince != null) body.pull = { since: options.pullSince };
+    return this._r("POST", "/api/im/evolution/sync", body);
+  }
+};
+function safeSlug(input) {
+  return input.replace(/[\/\\]/g, "").replace(/\.\./g, "").replace(/\0/g, "");
+}
+function guessMimeType(fileName) {
+  const ext = fileName.split(".").pop()?.toLowerCase() || "";
+  const map = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    bmp: "image/bmp",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    txt: "text/plain",
+    csv: "text/csv",
+    html: "text/html",
+    css: "text/css",
+    js: "text/javascript",
+    json: "application/json",
+    xml: "application/xml",
+    md: "text/markdown",
+    yaml: "text/yaml",
+    yml: "text/yaml",
+    zip: "application/zip",
+    gz: "application/gzip",
+    tar: "application/x-tar",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    mp4: "video/mp4",
+    webm: "video/webm"
+  };
+  return map[ext] || "application/octet-stream";
+}
+var FilesClient = class {
+  constructor(_r, _baseUrl, _fetchFn, _getAuthHeaders) {
+    this._r = _r;
+    this._baseUrl = _baseUrl;
+    this._fetchFn = _fetchFn;
+    this._getAuthHeaders = _getAuthHeaders;
+  }
+  /** Get a presigned upload URL */
+  async presign(options) {
+    return this._r("POST", "/api/im/files/presign", options);
+  }
+  /** Confirm an uploaded file (triggers validation + CDN activation) */
+  async confirm(uploadId) {
+    return this._r("POST", "/api/im/files/confirm", { uploadId });
+  }
+  /** Get storage quota */
+  async quota() {
+    return this._r("GET", "/api/im/files/quota");
+  }
+  /** Delete a file */
+  async delete(uploadId) {
+    return this._r("DELETE", `/api/im/files/${uploadId}`);
+  }
+  /** List allowed MIME types */
+  async types() {
+    return this._r("GET", "/api/im/files/types");
+  }
+  /** Initialize a multipart upload (for files > 10 MB) */
+  async initMultipart(opts) {
+    return this._r("POST", "/api/im/files/upload/init", opts);
+  }
+  /** Complete a multipart upload */
+  async completeMultipart(uploadId, parts) {
+    return this._r("POST", "/api/im/files/upload/complete", { uploadId, parts });
+  }
+  // --------------------------------------------------------------------------
+  // High-level convenience methods
+  // --------------------------------------------------------------------------
+  /**
+   * Upload a file (full lifecycle: presign → upload → confirm).
+   *
+   * @param input - File, Blob, Buffer, Uint8Array, or file path (Node.js string)
+   * @param opts  - Optional fileName, mimeType, onProgress
+   * @returns Confirmed upload result with CDN URL
+   */
+  async upload(input, opts) {
+    let bytes;
+    let fileName;
+    if (typeof input === "string") {
+      const fs = await import("fs");
+      const path = await import("path");
+      const buf = await fs.promises.readFile(input);
+      bytes = new Uint8Array(buf);
+      fileName = opts?.fileName || path.basename(input);
+    } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+      const ab = await input.arrayBuffer();
+      bytes = new Uint8Array(ab);
+      fileName = opts?.fileName || (input instanceof File ? input.name : "");
+      if (!fileName) throw new Error("fileName is required when uploading Blob without name");
+    } else if (input instanceof Uint8Array) {
+      bytes = input;
+      fileName = opts?.fileName || "";
+      if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
+    } else {
+      throw new Error("Unsupported input type");
+    }
+    const fileSize = bytes.byteLength;
+    const mimeType = opts?.mimeType || guessMimeType(fileName);
+    if (fileSize > 50 * 1024 * 1024) {
+      throw new Error("File exceeds maximum size of 50 MB");
+    }
+    if (fileSize <= 10 * 1024 * 1024) {
+      return this._uploadSimple(bytes, fileName, fileSize, mimeType, opts?.onProgress);
+    }
+    return this._uploadMultipart(bytes, fileName, fileSize, mimeType, opts?.onProgress);
+  }
+  /**
+   * Upload a file and send it as a message in one call.
+   *
+   * @param conversationId - Target conversation
+   * @param input          - File input (same as upload())
+   * @param opts           - Upload options + optional message content/parentId
+   */
+  async sendFile(conversationId, input, opts) {
+    const uploaded = await this.upload(input, opts);
+    const msgRes = await this._r("POST", `/api/im/messages/${conversationId}`, {
+      content: opts?.content || uploaded.fileName,
+      type: "file",
+      metadata: {
+        uploadId: uploaded.uploadId,
+        fileUrl: uploaded.cdnUrl,
+        fileName: uploaded.fileName,
+        fileSize: uploaded.fileSize,
+        mimeType: uploaded.mimeType
+      },
+      parentId: opts?.parentId
+    });
+    if (!msgRes.ok) {
+      throw new Error(msgRes.error?.message || "Failed to send file message");
+    }
+    return { upload: uploaded, message: msgRes.data };
+  }
+  // --------------------------------------------------------------------------
+  // Private upload helpers
+  // --------------------------------------------------------------------------
+  async _uploadSimple(bytes, fileName, fileSize, mimeType, onProgress) {
+    const presignRes = await this.presign({ fileName, fileSize, mimeType });
+    if (!presignRes.ok || !presignRes.data) {
+      throw new Error(presignRes.error?.message || "Presign failed");
+    }
+    const { uploadId, url, fields } = presignRes.data;
+    const formData = new FormData();
+    const isS3 = url.startsWith("http");
+    const uploadUrl = isS3 ? url : `${this._baseUrl}${url}`;
+    if (isS3) {
+      for (const [k, v] of Object.entries(fields)) formData.append(k, v);
+    }
+    const ab = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(ab).set(bytes);
+    formData.append("file", new Blob([ab], { type: mimeType }), fileName);
+    const headers = {};
+    if (!isS3) Object.assign(headers, this._getAuthHeaders());
+    const resp = await this._fetchFn(uploadUrl, { method: "POST", body: formData, headers });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Upload failed (${resp.status}): ${text}`);
+    }
+    onProgress?.(fileSize, fileSize);
+    const confirmRes = await this.confirm(uploadId);
+    if (!confirmRes.ok || !confirmRes.data) {
+      throw new Error(confirmRes.error?.message || "Confirm failed");
+    }
+    return confirmRes.data;
+  }
+  async _uploadMultipart(bytes, fileName, fileSize, mimeType, onProgress) {
+    const initRes = await this.initMultipart({ fileName, fileSize, mimeType });
+    if (!initRes.ok || !initRes.data) {
+      throw new Error(initRes.error?.message || "Multipart init failed");
+    }
+    const { uploadId, parts: partUrls } = initRes.data;
+    const CHUNK_SIZE = 5 * 1024 * 1024;
+    const completedParts = [];
+    let uploaded = 0;
+    for (const part of partUrls) {
+      const start = (part.partNumber - 1) * CHUNK_SIZE;
+      const end = Math.min(start + CHUNK_SIZE, fileSize);
+      const chunk = bytes.slice(start, end);
+      const isS3 = part.url.startsWith("http");
+      const partUrl = isS3 ? part.url : `${this._baseUrl}${part.url}`;
+      const headers = { "Content-Type": mimeType };
+      if (!isS3) Object.assign(headers, this._getAuthHeaders());
+      const resp = await this._fetchFn(partUrl, { method: "PUT", body: chunk, headers });
+      if (!resp.ok) {
+        throw new Error(`Part ${part.partNumber} upload failed (${resp.status})`);
+      }
+      const etag = resp.headers.get("ETag") || `"part-${part.partNumber}"`;
+      completedParts.push({ partNumber: part.partNumber, etag });
+      uploaded += chunk.byteLength;
+      onProgress?.(uploaded, fileSize);
+    }
+    const completeRes = await this.completeMultipart(uploadId, completedParts);
+    if (!completeRes.ok || !completeRes.data) {
+      throw new Error(completeRes.error?.message || "Multipart complete failed");
+    }
+    return completeRes.data;
+  }
+};
+var IMRealtimeClient = class {
+  constructor(_wsBase) {
+    this._wsBase = _wsBase;
+  }
+  /** Get the WebSocket URL */
+  wsUrl(token) {
+    const base = this._wsBase.replace(/^http/, "ws");
+    return token ? `${base}/ws?token=${token}` : `${base}/ws`;
+  }
+  /** Get the SSE URL */
+  sseUrl(token) {
+    return token ? `${this._wsBase}/sse?token=${token}` : `${this._wsBase}/sse`;
+  }
+  /** Create a WebSocket client. Call .connect() to establish connection. */
+  connectWS(config) {
+    return new RealtimeWSClient(this._wsBase, config);
+  }
+  /** Create an SSE client. Call .connect() to establish connection. */
+  connectSSE(config) {
+    return new RealtimeSSEClient(this._wsBase, config);
+  }
+};
+var IMClient = class {
+  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
+    this.account = new AccountClient(request);
+    this.direct = new DirectClient(request);
+    this.groups = new GroupsClient(request);
+    this.conversations = new ConversationsClient(request);
+    this.messages = new MessagesClient(request);
+    this.contacts = new ContactsClient(request);
+    this.bindings = new BindingsClient(request);
+    this.credits = new CreditsClient(request);
+    this.workspace = new WorkspaceClient(request);
+    this.tasks = new TasksClient(request);
+    this.memory = new MemoryClient(request);
+    this.knowledge = new KnowledgeLinkClient(request);
+    this.identity = new IdentityClient(request);
+    this.security = new SecurityClient(request);
+    this.evolution = new EvolutionClient(request);
+    this.community = new CommunityHub(request, communityHubConfig ?? void 0);
+    this.files = new FilesClient(request, wsBase, fetchFn, getAuthHeaders);
+    this.realtime = new IMRealtimeClient(wsBase);
+    this.offline = offlineManager ?? null;
+  }
+  /** IM health check */
+  async health() {
+    return this.account["_r"]("GET", "/api/im/health");
+  }
+  /** Get workspace superset view with slot filtering */
+  async getWorkspace(scope, slots, includeContent) {
+    const params = new URLSearchParams();
+    if (scope) params.set("scope", scope);
+    if (slots?.length) params.set("slots", slots.join(","));
+    if (includeContent) params.set("includeContent", "true");
+    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+  }
+};
+var PrismerClient = class {
+  constructor(config = {}) {
+    this._offlineManager = null;
+    /** AIP identity for auto-signing (v1.8.0 S1) */
+    this._identity = null;
+    this._identityReady = null;
+    const resolvedApiKey = resolveApiKey(config.apiKey);
+    if (resolvedApiKey && !resolvedApiKey.startsWith("sk-prismer-") && !resolvedApiKey.startsWith("eyJ")) {
+      console.warn('Warning: API key should start with "sk-prismer-" (or "eyJ" for IM JWT)');
+    }
+    this.apiKey = resolvedApiKey;
+    const envUrl = ENVIRONMENTS[config.environment || "production"];
+    this.baseUrl = (resolveBaseUrl(config.baseUrl) || envUrl).replace(/\/$/, "");
+    this.timeout = config.timeout || 3e4;
+    this.fetchFn = config.fetch || fetch;
+    this.imAgent = config.imAgent;
+    if (config.identity) {
+      if (config.identity === "auto" && this.apiKey) {
+        this._identityReady = AIPIdentity.fromApiKey(this.apiKey).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      } else if (typeof config.identity === "object" && config.identity.privateKey) {
+        const keyBytes = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(config.identity.privateKey, "base64")) : new Uint8Array(atob(config.identity.privateKey).split("").map((c) => c.charCodeAt(0)));
+        this._identityReady = AIPIdentity.fromPrivateKey(keyBytes).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      }
+    }
+    if (config.offline) {
+      this._offlineManager = new OfflineManager(
+        config.offline.storage,
+        (m, p, b, q) => this._request(m, p, b, q),
+        config.offline
+      );
+      this._offlineManager.init().catch(
+        (err) => console.warn("[PrismerSDK] Offline storage init failed:", err)
+      );
+    }
+    let imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    if (config.identity) {
+      const baseRequest = imRequest;
+      imRequest = (method, path, body, query) => {
+        if (method === "POST" && path.includes("/messages") && body) {
+          const b = body;
+          if (!b.signature && !b.skipSigning) {
+            const ready = this._identityReady || Promise.resolve();
+            return ready.then(() => {
+              if (this._identity) {
+                return this._signAndSend(baseRequest, method, path, b, query);
+              }
+              return baseRequest(method, path, body, query);
+            });
+          }
+        }
+        return baseRequest(method, path, body, query);
+      };
+    }
+    this.im = new IMClient(
+      imRequest,
+      this.baseUrl,
+      this.fetchFn,
+      () => this._getAuthHeaders(),
+      this._offlineManager,
+      config.community ?? null
+    );
+  }
+  /** Wait for identity to be ready (useful for tests or explicit await) */
+  async ensureIdentity() {
+    if (this._identityReady) await this._identityReady;
+    return this._identity;
+  }
+  /** Auto-sign a message body and send (v1.8.0 S1) */
+  async _signAndSend(baseRequest, method, path, body, query) {
+    if (this._identityReady) await this._identityReady;
+    if (!this._identity) return baseRequest(method, path, body, query);
+    const content = body.content || "";
+    const contentHashBytes = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content))
+    );
+    const contentHash = Array.from(contentHashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const timestamp = Date.now();
+    const payload = `1|${this._identity.did}|${body.type || "text"}|${timestamp}|${contentHash}`;
+    const payloadBytes = new TextEncoder().encode(payload);
+    const signature = await this._identity.sign(payloadBytes);
+    return baseRequest(method, path, {
+      ...body,
+      secVersion: 1,
+      senderDid: this._identity.did,
+      contentHash,
+      signature,
+      signedAt: timestamp
+    }, query);
+  }
+  /** Build auth headers for raw HTTP requests (used by file upload) */
+  _getAuthHeaders() {
+    const headers = {};
+    if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+    if (this.imAgent) headers["X-IM-Agent"] = this.imAgent;
+    return headers;
+  }
+  /**
+   * Set or update the auth token (API key or IM JWT).
+   * Useful after anonymous registration to set the returned JWT.
+   */
+  setToken(token) {
+    this.apiKey = token;
+  }
+  /** Cleanup resources (offline manager, timers). Call when disposing the client. */
+  async destroy() {
+    if (this._offlineManager) {
+      await this._offlineManager.destroy();
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Internal request helper
+  // --------------------------------------------------------------------------
+  async _request(method, path, body, query, _isRetry) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      let url = `${this.baseUrl}${path}`;
+      if (query && Object.keys(query).length > 0) {
+        url += "?" + new URLSearchParams(query).toString();
+      }
+      const headers = {};
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      if (this.imAgent) {
+        headers["X-IM-Agent"] = this.imAgent;
+      }
+      const init = { method, headers, signal: controller.signal };
+      if (body !== void 0) {
+        headers["Content-Type"] = "application/json";
+        init.body = JSON.stringify(body);
+      }
+      const response = await this.fetchFn(url, init);
+      const data = await response.json();
+      if (response.status === 401 && this.apiKey.startsWith("eyJ") && !_isRetry && !path.includes("/token/refresh")) {
+        try {
+          const refreshRes = await this._request("POST", "/api/im/token/refresh", void 0, void 0, true);
+          if (refreshRes?.ok && refreshRes?.data?.token) {
+            this.apiKey = refreshRes.data.token;
+            return this._request(method, path, body, query, true);
+          }
+        } catch {
+        }
+      }
+      if (!response.ok) {
+        const err = data.error || { code: "HTTP_ERROR", message: `Request failed with status ${response.status}` };
+        return { ...data, success: false, ok: false, error: err };
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return { success: false, ok: false, error: { code: "TIMEOUT", message: "Request timed out" } };
+      }
+      return {
+        success: false,
+        ok: false,
+        error: { code: "NETWORK_ERROR", message: error instanceof Error ? error.message : "Unknown error" }
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Context API
+  // --------------------------------------------------------------------------
+  /** Load content from URL(s) or search query */
+  async load(input, options = {}) {
+    return this._request("POST", "/api/context/load", {
+      input,
+      inputType: options.inputType,
+      processUncached: options.processUncached,
+      search: options.search,
+      processing: options.processing,
+      return: options.return,
+      ranking: options.ranking
+    });
+  }
+  /** Save content to Prismer cache */
+  async save(options) {
+    return this._request("POST", "/api/context/save", options);
+  }
+  /** Batch save multiple items (max 50) */
+  async saveBatch(items) {
+    return this.save({ items });
+  }
+  // --------------------------------------------------------------------------
+  // Parse API
+  // --------------------------------------------------------------------------
+  /** Parse a document (PDF, image) into structured content */
+  async parse(options) {
+    return this._request("POST", "/api/parse", options);
+  }
+  /** Convenience: parse a PDF by URL */
+  async parsePdf(url, mode = "fast") {
+    return this.parse({ url, mode });
+  }
+  /** Check status of an async parse task */
+  async parseStatus(taskId) {
+    return this._request("GET", `/api/parse/status/${taskId}`);
+  }
+  /** Get result of a completed async parse task */
+  async parseResult(taskId) {
+    return this._request("GET", `/api/parse/result/${taskId}`);
+  }
+  // --------------------------------------------------------------------------
+  // Convenience
+  // --------------------------------------------------------------------------
+  /** Search for content (convenience wrapper around load with query mode) */
+  async search(query, options) {
+    return this.load(query, {
+      inputType: "query",
+      search: options?.topK ? { topK: options.topK } : void 0,
+      return: options?.returnTopK || options?.format ? { topK: options?.returnTopK, format: options?.format } : void 0,
+      ranking: options?.ranking ? { preset: options.ranking } : void 0
+    });
+  }
+};
+var index_default = PrismerClient;
+function createClient(config) {
+  return new PrismerClient(config);
+}
+
+export {
+  __require,
+  RealtimeWSClient,
+  RealtimeSSEClient,
+  OfflineManager,
+  AttachmentQueue,
+  CommunityHub,
+  AIPIdentity,
+  ENVIRONMENTS,
+  MemoryStorage,
+  IndexedDBStorage,
+  SQLiteStorage,
+  TabCoordinator,
+  E2EEncryption,
+  encryptForSend,
+  decryptOnReceive,
+  encryptFile,
+  decryptFile,
+  encryptContext,
+  decryptContext,
+  decryptMessages,
+  EvolutionCache,
+  extractSignals,
+  createEnrichedExtractor,
+  EvolutionRuntime,
+  AccountClient,
+  DirectClient,
+  GroupsClient,
+  ConversationsClient,
+  MessagesClient,
+  ContactsClient,
+  BindingsClient,
+  CreditsClient,
+  WorkspaceClient,
+  TasksClient,
+  MemoryClient,
+  KnowledgeLinkClient,
+  IdentityClient,
+  SecurityClient,
+  EvolutionClient,
+  safeSlug,
+  guessMimeType,
+  FilesClient,
+  IMRealtimeClient,
+  IMClient,
+  PrismerClient,
+  index_default,
+  createClient
+};