@deeprespond/im-tauri 0.0.0-stage → 1.0.0-alpha

package/dist/chunk-DMEEI2YZ.js

@@ -0,0 +1,1161 @@
+import { DRError } from '@deeprespond/im-web';
+import { WorkerTimers, extractKey, isValidKey } from '@deeprespond/im-web/platform';
+import { isTauri, Channel, invoke } from '@tauri-apps/api/core';
+
+// src/adapter/files.ts
+var CHUNK = 4 * 1024 * 1024;
+var taskSeq = 0;
+function newTask(prefix) {
+  taskSeq += 1;
+  return `${prefix}-${Date.now().toString(36)}-${taskSeq}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function fileUrl(path, os) {
+  const encoded = encodeURIComponent(path);
+  return os === "windows" ? `http://drim-file.localhost/${encoded}` : `drim-file://localhost/${encoded}`;
+}
+function osFromUserAgent(ua) {
+  if (/Windows/.test(ua)) return "windows";
+  if (/Mac OS X|Macintosh/.test(ua)) return "macos";
+  return "linux";
+}
+function pluginFiles(bridge) {
+  const os = () => bridge.info?.os ?? osFromUserAgent(typeof navigator !== "undefined" ? navigator.userAgent : "");
+  const writeBlob = async (blob, opts = {}) => {
+    let handle = "";
+    let result = null;
+    const name = opts.name ?? blob.name ?? "";
+    for (let offset = 0; offset < blob.size || result === null; offset += CHUNK) {
+      const end = Math.min(blob.size, offset + CHUNK);
+      const bytes = new Uint8Array(await blob.slice(offset, end).arrayBuffer());
+      const final = end >= blob.size;
+      result = await bridge.callRaw("files_write", bytes, {
+        "x-drim-handle": handle,
+        "x-drim-name": encodeURIComponent(name),
+        "x-drim-final": final ? "1" : "0"
+      });
+      handle = result.handle;
+      if (final) break;
+    }
+    const out = { path: result.path, temp: true, size: result.size };
+    if (name) out.name = name;
+    if (blob.type) out.type = blob.type;
+    return out;
+  };
+  return {
+    stat: (path) => bridge.call("files_stat", { path }),
+    read: async (path, offset, length) => new Uint8Array(await bridge.call("files_read", { path, offset, length })),
+    writeBlob,
+    writeBlobTemp: (blob, name) => writeBlob(blob, { name }),
+    persist: (file, opts) => bridge.call("files_persist", { path: file.path, temp: file.temp === true, app_key: opts.appKey, username: opts.username, copy_max_bytes: opts.copyMaxBytes }),
+    release: (path, owned) => bridge.call("files_release", { path, owned }),
+    uploadPart: async (req) => {
+      const task = newTask("up");
+      const off = bridge.on("upload_progress", (event) => {
+        if (event.task === task && typeof event.loaded === "number") req.onProgress?.(event.loaded);
+      });
+      const onAbort = () => void bridge.call("files_cancel", { task }).catch(() => {
+      });
+      req.signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const r = await bridge.call("files_upload_part", {
+          task,
+          path: req.path,
+          offset: req.offset,
+          length: req.length,
+          url: req.url,
+          method: req.method,
+          headers: req.headers,
+          expect: req.expect ?? null,
+          patches: req.patches ?? null
+        });
+        return r.status;
+      } finally {
+        off();
+        req.signal?.removeEventListener("abort", onAbort);
+      }
+    },
+    prepareImage: (path, opts) => bridge.call("files_prepare_image", {
+      path,
+      original: opts.original,
+      max_side: opts.maxSide,
+      quality: opts.quality,
+      max_bytes: opts.maxBytes,
+      max_pixels: opts.maxPixels
+    }),
+    prepareVideo: (path) => bridge.call("files_prepare_video", { path }),
+    url: (path) => fileUrl(path, os())
+  };
+}
+async function blobsToPaths(value, write) {
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    const written = await write(value, value.name);
+    const out = { path: written.path, temp: true };
+    if (written.name) out.name = written.name;
+    if (value.type) out.type = value.type;
+    return out;
+  }
+  if (Array.isArray(value)) return Promise.all(value.map((v) => blobsToPaths(v, write)));
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const entries = await Promise.all(Object.entries(value).map(async ([k, v]) => [k, await blobsToPaths(v, write)]));
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function pluginChannel(bridge, name, onError) {
+  let closed = false;
+  let pending = [];
+  let flushing = false;
+  const joined = bridge.call("bus_join", { name }).catch(onError);
+  const flush = async () => {
+    if (flushing) return;
+    flushing = true;
+    try {
+      await joined;
+      while (pending.length > 0) {
+        const msgs = pending;
+        pending = [];
+        await bridge.call("bus_post", { name, msgs }).catch(onError);
+      }
+    } finally {
+      flushing = false;
+      if (pending.length > 0 && !closed) void flush();
+    }
+  };
+  let willSet = false;
+  const wrapper = {
+    onmessage: null,
+    postMessage: (msg) => {
+      if (closed) return;
+      pending.push(encode(msg));
+      const m = msg;
+      if (!willSet && m && typeof m === "object" && typeof m.from === "string" && typeof m.v === "number") {
+        willSet = true;
+        void joined.then(() => bridge.call("bus_will", { name, msg: encode({ v: m.v, from: m.from, type: "bye" }) })).catch(() => {
+        });
+      }
+      void flush();
+    },
+    close: () => {
+      if (closed) return;
+      closed = true;
+      off();
+      void flush().then(() => bridge.call("bus_leave", { name })).catch(() => {
+      });
+    }
+  };
+  const off = bridge.on("bus", (event) => {
+    if (closed || event.name !== name || typeof event.msg !== "string") return;
+    let decoded;
+    try {
+      decoded = decode(event.msg);
+    } catch {
+      return;
+    }
+    wrapper.onmessage?.(decoded);
+  });
+  return wrapper;
+}
+function encode(msg) {
+  return JSON.stringify(msg, function replacer(_key, value) {
+    if (value instanceof DRError) return { $drerr: value.toData() };
+    if (value instanceof Uint8Array) return { $u8: toBase64(value) };
+    if (typeof Blob !== "undefined" && value instanceof Blob) throw Object.assign(new Error("Blob 不能经插件的频道传递"), { name: "DataCloneError" });
+    if (typeof value === "function") throw Object.assign(new Error("函数不能经插件的频道传递"), { name: "DataCloneError" });
+    if (value instanceof Error) return { $err: { name: value.name, message: value.message } };
+    return value;
+  });
+}
+function decode(text) {
+  return JSON.parse(text, (_key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const v = value;
+      if ("$drerr" in v) return DRError.fromData(v.$drerr);
+      if ("$u8" in v && typeof v.$u8 === "string") return fromBase64(v.$u8);
+      if ("$err" in v) {
+        const e = v.$err;
+        return Object.assign(new Error(e.message ?? ""), { name: e.name ?? "Error" });
+      }
+    }
+    return value;
+  });
+}
+function toBase64(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+  return btoa(s);
+}
+function fromBase64(text) {
+  const s = atob(text);
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+var QUEUE_WAIT_MS = 1e4;
+var TxAbort = class extends Error {
+  constructor(reason) {
+    super("aborted");
+    this.reason = reason;
+  }
+  reason;
+};
+var TauriDatabase = class _TauriDatabase {
+  constructor(bridge, handle, schema, appKey, username, reset) {
+    this.bridge = bridge;
+    this.handle = handle;
+    this.appKey = appKey;
+    this.username = username;
+    this.storeNames = schema.map((s) => s.name);
+    this.#schemas = new Map(schema.map((s) => [s.name, s]));
+    if (reset) this.resetReason = reset;
+    this.#off = bridge.on("db_deleted", (event) => {
+      if (event.app_key !== appKey || String(event.username).toLowerCase() !== username) return;
+      for (const listener of [...this.#listeners]) listener(null);
+    });
+  }
+  bridge;
+  handle;
+  appKey;
+  username;
+  storeNames;
+  resetReason;
+  #schemas;
+  #writeChain = Promise.resolve();
+  #closed = false;
+  #listeners = /* @__PURE__ */ new Set();
+  #off;
+  static async open(bridge, appKey, name, version, upgrade, encrypt) {
+    const prefix = `im:${appKey}:`;
+    if (!name.startsWith(prefix)) throw new DRError({ code: "invalid_state", message: `数据库名不对：${name}`, details: { reason: "database_name" }, source: "local" });
+    const username = name.slice(prefix.length).toLowerCase();
+    const schema = upgrade(0, version);
+    const r = await bridge.call("db_open", { app_key: appKey, username, version, schema, encrypt });
+    return new _TauriDatabase(bridge, r.db, schema, appKey, username, r.reset);
+  }
+  async transaction(stores, mode, fn, opts) {
+    if (this.#closed) throw new DRError({ code: "storage_error", message: "closed", details: { reason: "closed" }, source: "local" });
+    for (const store of stores) if (!this.#schemas.has(store)) throw new DRError({ code: "storage_error", message: `没有对象仓库 ${store}`, details: { reason: "NotFoundError" }, source: "local" });
+    let release = () => {
+    };
+    if (mode === "readwrite") {
+      const previous = this.#writeChain;
+      this.#writeChain = new Promise((resolve) => release = resolve);
+      await waitFor(previous);
+    } else {
+      await waitFor(this.#writeChain);
+    }
+    try {
+      const { tx } = await this.bridge.call("tx_begin", { db: this.handle, stores, mode, durability: opts?.durability ?? "default" });
+      const txLike = new PluginTx(this.bridge, tx, this.#schemas, mode);
+      let result;
+      try {
+        result = await fn(txLike);
+      } catch (err) {
+        await this.bridge.call("tx_abort", { tx }).catch(() => {
+        });
+        if (err instanceof TxAbort) throw err.reason;
+        throw err;
+      }
+      if (txLike.aborted) {
+        await this.bridge.call("tx_abort", { tx }).catch(() => {
+        });
+        throw txLike.aborted.reason;
+      }
+      await this.bridge.call("tx_commit", { tx, ops: txLike.takeWrites() });
+      return result;
+    } finally {
+      release();
+    }
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#off();
+    void this.bridge.call("db_close", { db: this.handle }).catch(() => {
+    });
+  }
+  onVersionChange(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+};
+function waitFor(p) {
+  return Promise.race([p, new Promise((resolve) => setTimeout(resolve, QUEUE_WAIT_MS))]);
+}
+var PluginTx = class {
+  constructor(bridge, tx, schemas, mode) {
+    this.bridge = bridge;
+    this.tx = tx;
+    this.schemas = schemas;
+    this.mode = mode;
+  }
+  bridge;
+  tx;
+  schemas;
+  mode;
+  #writes = [];
+  aborted = null;
+  takeWrites() {
+    const out = this.#writes;
+    this.#writes = [];
+    return out;
+  }
+  async #flush() {
+    if (this.#writes.length === 0) return;
+    await this.bridge.call("tx_write", { tx: this.tx, ops: this.takeWrites() });
+  }
+  async #read(args) {
+    this.#check();
+    await this.#flush();
+    return this.bridge.call("tx_read", { tx: this.tx, ...args });
+  }
+  #check() {
+    if (this.aborted) throw this.aborted;
+  }
+  #requireWrite(store) {
+    this.#check();
+    if (this.mode !== "readwrite") throw new DRError({ code: "storage_error", message: "ReadOnlyError", details: { reason: "ReadOnlyError" }, source: "local" });
+    const schema = this.schemas.get(store);
+    if (!schema) throw new DRError({ code: "storage_error", message: `没有对象仓库 ${store}`, details: { reason: "NotFoundError" }, source: "local" });
+    return schema;
+  }
+  async get(store, key) {
+    const value = await this.#read({ op: "get", store, key });
+    return value ?? void 0;
+  }
+  async getAll(store, p = {}) {
+    return this.#read({ op: "get_all", store, index: p.index, range: p.range, limit: p.limit });
+  }
+  async count(store, p = {}) {
+    return this.#read({ op: "count", store, index: p.index, range: p.range });
+  }
+  async *iterate(store, p) {
+    let remaining = p.limit;
+    let cursor = null;
+    for (; ; ) {
+      const batch = await this.#read({ op: "iterate", store, index: p.index, range: p.range, direction: p.direction ?? "next", limit: remaining, cursor });
+      for (const item of batch.items) yield item;
+      if (remaining !== void 0) remaining -= batch.items.length;
+      if (!batch.cursor || remaining !== void 0 && remaining <= 0) return;
+      cursor = batch.cursor;
+    }
+  }
+  async put(store, value) {
+    const schema = this.#requireWrite(store);
+    if (extractKey(value, schema.keyPath) === void 0) throw new DRError({ code: "storage_error", message: `${store} 的记录没有合法的主键`, details: { reason: "DataError" }, source: "local" });
+    this.#writes.push({ op: "put", store, value });
+  }
+  async delete(store, key) {
+    this.#requireWrite(store);
+    if (isValidKey(key)) this.#writes.push({ op: "delete", store, key });
+    else this.#writes.push({ op: "delete", store, range: key });
+  }
+  async clear(store) {
+    this.#requireWrite(store);
+    this.#writes.push({ op: "clear", store });
+  }
+  abort(reason) {
+    this.aborted = new TxAbort(reason);
+    throw this.aborted;
+  }
+};
+
+// src/adapter/kv.ts
+var DEVICE_ID_KEY = "im:device_id";
+function parse(appKey, key) {
+  const prefix = `im:${appKey}:`;
+  if (!key.startsWith(prefix)) return null;
+  switch (key.slice(prefix.length)) {
+    case "session":
+      return "session";
+    case "pending_logout":
+      return "pending_logout";
+    case "dbs":
+      return "users";
+    default:
+      return null;
+  }
+}
+function hintKey(appKey) {
+  return `drim:${appKey}:session_hint`;
+}
+function localStorageSafe() {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+var EngineKv = class {
+  constructor(bridge, appKey, onError) {
+    this.bridge = bridge;
+    this.appKey = appKey;
+    this.onError = onError;
+  }
+  bridge;
+  appKey;
+  onError;
+  #cache = /* @__PURE__ */ new Map();
+  #queue = Promise.resolve();
+  async load() {
+    const r = await this.bridge.call("secure_load", { app_key: this.appKey });
+    const set = (key, value) => value === null ? this.#cache.delete(key) : this.#cache.set(key, value);
+    set(`im:${this.appKey}:session`, r.session);
+    set(`im:${this.appKey}:pending_logout`, r.pending_logout);
+    set(`im:${this.appKey}:dbs`, r.users);
+    this.#cache.set(DEVICE_ID_KEY, r.device_id);
+    this.#writeHint(r.session);
+  }
+  get(key) {
+    return this.#cache.get(key) ?? null;
+  }
+  set(key, value) {
+    if (key === DEVICE_ID_KEY) return;
+    const target = parse(this.appKey, key);
+    let stored = value;
+    if (target === "session") stored = this.#withDevice(value);
+    this.#cache.set(key, stored);
+    if (target) this.#persist(target, stored);
+    if (target === "session") this.#writeHint(stored);
+  }
+  remove(key) {
+    if (key === DEVICE_ID_KEY) return;
+    const target = parse(this.appKey, key);
+    this.#cache.delete(key);
+    if (target) this.#persist(target, null);
+    if (target === "session") this.#writeHint(null);
+  }
+  onChange() {
+    return () => {
+    };
+  }
+  /** 等全部写入交给插件（退出前）。 */
+  flush() {
+    return this.#queue;
+  }
+  /** 会话中记下登录时的设备标识（《1.本地存储》第 2.3 节）：重装、复制到另一台电脑后据此丢弃。 */
+  #withDevice(value) {
+    const deviceId = this.#cache.get(DEVICE_ID_KEY);
+    if (!deviceId) return value;
+    try {
+      const session = JSON.parse(value);
+      return JSON.stringify({ ...session, device_id: deviceId });
+    } catch {
+      return value;
+    }
+  }
+  #persist(key, value) {
+    this.#queue = this.#queue.then(() => this.bridge.call("secure_set", { app_key: this.appKey, key, value })).catch((err) => this.onError(err));
+  }
+  #writeHint(session) {
+    const storage = localStorageSafe();
+    if (!storage) return;
+    try {
+      const parsed = session ? JSON.parse(session) : null;
+      if (parsed && typeof parsed.username === "string" && typeof parsed.session_id === "string") {
+        storage.setItem(hintKey(this.appKey), JSON.stringify({ username: parsed.username, session_id: parsed.session_id }));
+      } else {
+        storage.removeItem(hintKey(this.appKey));
+      }
+    } catch {
+    }
+  }
+};
+var WindowKv = class {
+  constructor(bridge, appKey) {
+    this.bridge = bridge;
+    this.appKey = appKey;
+    this.#sessionKey = `im:${appKey}:session`;
+    this.#hint = readHint(appKey);
+    bridge.on("kv", (event) => {
+      if (event.app_key !== this.appKey || event.key !== "session") return;
+      this.#update(event.hint ?? null);
+    });
+    void this.refresh().catch(() => {
+    });
+  }
+  bridge;
+  appKey;
+  #hint;
+  #listeners = /* @__PURE__ */ new Set();
+  #sessionKey;
+  get(key) {
+    if (key === DEVICE_ID_KEY) return this.bridge.info?.device_id ?? null;
+    if (key !== this.#sessionKey || !this.#hint) return null;
+    return JSON.stringify({ v: 1, username: this.#hint.username, session_id: this.#hint.session_id, access_token: "", access_expires_at: null, refresh_token: "", refresh_expires_at: null, login_method: "password" });
+  }
+  set() {
+  }
+  remove() {
+  }
+  onChange(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  async refresh() {
+    const hint = await this.bridge.call("session_hint", { app_key: this.appKey });
+    this.#update(hint);
+  }
+  #update(hint) {
+    const same = hint === null ? this.#hint === null : this.#hint !== null && this.#hint.username === hint.username && this.#hint.session_id === hint.session_id;
+    if (same) return;
+    this.#hint = hint ? { username: hint.username, session_id: hint.session_id } : null;
+    for (const listener of [...this.#listeners]) listener(this.#sessionKey);
+  }
+};
+function readHint(appKey) {
+  const storage = localStorageSafe();
+  if (!storage) return null;
+  try {
+    const raw = storage.getItem(hintKey(appKey));
+    if (!raw) return null;
+    const hint = JSON.parse(raw);
+    return typeof hint.username === "string" && typeof hint.session_id === "string" ? { username: hint.username, session_id: hint.session_id } : null;
+  } catch {
+    return null;
+  }
+}
+function memoryKv() {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => data.get(key) ?? null,
+    set: (key, value) => void data.set(key, value),
+    remove: (key) => void data.delete(key),
+    onChange: () => () => {
+    }
+  };
+}
+
+// src/adapter/locks.ts
+function abortError() {
+  return Object.assign(new Error("aborted"), { name: "AbortError" });
+}
+var PluginLocks = class {
+  constructor(bridge) {
+    this.bridge = bridge;
+    bridge.on("lock_stolen", (event) => {
+      const reject = this.#stolen.get(String(event.id));
+      if (reject) {
+        this.#stolen.delete(String(event.id));
+        reject(abortError());
+      }
+    });
+  }
+  bridge;
+  native = true;
+  #stolen = /* @__PURE__ */ new Map();
+  #seq = 0;
+  async request(name, opts, fn) {
+    if (opts.signal?.aborted) throw opts.signal.reason ?? abortError();
+    const id = `${this.bridge.label}:${++this.#seq}:${Math.random().toString(36).slice(2)}`;
+    const onAbort = () => void this.bridge.call("lock_cancel", { id }).catch(() => {
+    });
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    let granted;
+    try {
+      granted = await this.bridge.call("lock_request", { name, id, steal: opts.steal === true, if_available: opts.ifAvailable === true });
+    } catch (err) {
+      if (opts.signal?.aborted) throw opts.signal.reason ?? abortError();
+      throw err;
+    } finally {
+      opts.signal?.removeEventListener("abort", onAbort);
+    }
+    if (!granted) return fn(false);
+    let stolen = false;
+    const stolenPromise = new Promise((_, reject) => {
+      this.#stolen.set(id, (err) => {
+        stolen = true;
+        reject(err);
+      });
+    });
+    stolenPromise.catch(() => {
+    });
+    try {
+      return await Promise.race([fn(true), stolenPromise]);
+    } finally {
+      this.#stolen.delete(id);
+      if (!stolen) void this.bridge.call("lock_release", { id }).catch(() => {
+      });
+    }
+  }
+};
+
+// src/adapter/visibility.ts
+function engineVisibility() {
+  return { visible: () => false, focused: () => false, onChange: () => () => {
+  } };
+}
+function windowVisibility(bridge) {
+  const doc = typeof document !== "undefined" ? document : void 0;
+  const pageVisible = () => doc ? doc.visibilityState !== "hidden" : true;
+  const pageFocused = () => doc && typeof doc.hasFocus === "function" ? doc.hasFocus() : true;
+  let plugin = { visible: pageVisible(), focused: pageFocused() };
+  let last = current();
+  const listeners = /* @__PURE__ */ new Set();
+  function current() {
+    const visible = pageVisible() && plugin.visible;
+    return { visible, focused: visible && plugin.focused };
+  }
+  function fire() {
+    const next = current();
+    if (next.visible === last.visible && next.focused === last.focused) return;
+    last = next;
+    for (const listener of [...listeners]) listener(next);
+  }
+  function apply(state) {
+    if (!state) return;
+    plugin = { visible: state.visible !== false, focused: state.focused === true };
+    fire();
+  }
+  void bridge.ready.then((info) => apply(info.window), () => {
+  });
+  bridge.on("window", (event) => apply(event));
+  bridge.on("screen_lock", () => void refresh());
+  const refresh = async () => {
+    try {
+      apply(await bridge.call("window_state"));
+    } catch {
+      fire();
+    }
+  };
+  if (doc && typeof window !== "undefined") {
+    const onFocus = () => {
+      plugin = { ...plugin, focused: true, visible: true };
+      fire();
+      void refresh();
+    };
+    const onBlur = () => {
+      plugin = { ...plugin, focused: false };
+      fire();
+      void refresh();
+    };
+    doc.addEventListener("visibilitychange", () => {
+      fire();
+      void refresh();
+    });
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+  }
+  return {
+    visible: () => current().visible,
+    focused: () => current().focused,
+    onChange: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function pluginNetwork(bridge) {
+  let pluginOnline = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const navOnline = () => typeof navigator !== "undefined" && typeof navigator.onLine === "boolean" ? navigator.onLine : true;
+  const online = () => pluginOnline ?? navOnline();
+  const fire = (value) => {
+    for (const listener of [...listeners]) listener(value);
+  };
+  bridge.on("network", (event) => {
+    pluginOnline = event.online !== false;
+    fire(online());
+  });
+  if (typeof window !== "undefined") {
+    window.addEventListener("online", () => fire(true));
+    window.addEventListener("offline", () => {
+      if (pluginOnline !== true) fire(false);
+    });
+  }
+  return {
+    online,
+    onChange: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/adapter/index.ts
+function createTauriPlatform(opts) {
+  const { bridge, appKey, role } = opts;
+  const engineKv = role === "leader" ? new EngineKv(bridge, appKey, (err) => opts.onWarn("写入安全存储失败", err)) : null;
+  const windowKv = role === "follower" ? new WindowKv(bridge, appKey) : null;
+  const files = pluginFiles(bridge);
+  let workerTimers = null;
+  const precise = () => {
+    if (!workerTimers) workerTimers = new WorkerTimers((reason) => opts.onWarn(`计时器 Worker 不可用，改用页面的计时器：${reason}`));
+    return workerTimers;
+  };
+  const g = globalThis;
+  const clock = {
+    now: () => Date.now(),
+    monotonic: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+    setTimeout: (fn, ms) => g.setTimeout(fn, ms),
+    clearTimeout: (id) => g.clearTimeout(id),
+    // 存活信号、心跳、续期计划在专用 Worker 中计时，不受隐藏页面的节流（《2.功能概述文档》第 4.5 节）
+    setPreciseTimeout: (fn, ms) => precise().setTimeout(fn, ms),
+    clearPreciseTimeout: (id) => precise().clearTimeout(id)
+  };
+  let engineState = bridge.info?.engine_state ?? "starting";
+  let host = null;
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  const platform = {
+    fetch: (input, init) => g.fetch(input, init),
+    createWebSocket: (url, protocols) => {
+      if (role !== "leader") throw new DRError({ code: "invalid_state", message: "界面窗口不建立长连接", details: { reason: "not_engine_window" }, source: "local" });
+      return wrapWebSocket(new WebSocket(url, protocols));
+    },
+    kv: engineKv ?? windowKv,
+    sessionKv: memoryKv(),
+    openDatabase: (name, version, upgrade) => TauriDatabase.open(bridge, appKey, name, version, upgrade, opts.encrypt === true),
+    deleteDatabase: async (name) => {
+      if (role !== "leader") return;
+      const prefix = `im:${appKey}:`;
+      if (!name.startsWith(prefix)) return;
+      await bridge.call("db_delete", { app_key: appKey, username: name.slice(prefix.length) });
+    },
+    locks: new PluginLocks(bridge),
+    channel: (name) => pluginChannel(bridge, name, (err) => opts.onWarn(`频道消息发送失败：${name}`, err)),
+    clock,
+    visibility: role === "leader" ? engineVisibility() : windowVisibility(bridge),
+    lifecycle: pageLifecycle(),
+    network: pluginNetwork(bridge),
+    random: cryptoRandom(),
+    environment: {
+      userAgent: ua,
+      osVersion: async () => (await bridge.ready).os_version,
+      secureContext: true,
+      browser: true,
+      missingCapabilities: () => {
+        const missing = [];
+        const any = globalThis;
+        for (const name of ["WebSocket", "fetch", "TextEncoder", "queueMicrotask", "AbortController", "Worker"]) if (typeof any[name] === "undefined") missing.push(name);
+        if (typeof globalThis.crypto?.randomUUID !== "function") missing.push("crypto.randomUUID");
+        if (typeof any.OffscreenCanvas === "undefined") missing.push("OffscreenCanvas");
+        return missing;
+      },
+      deviceName: () => bridge.info?.computer_name || null
+    },
+    createWorker: (source) => {
+      const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+      const worker = new Worker(url);
+      const wrapper = {
+        postMessage: (msg, transfer) => worker.postMessage(msg, transfer ?? []),
+        onmessage: null,
+        terminate: () => {
+          worker.terminate();
+          URL.revokeObjectURL(url);
+        }
+      };
+      worker.onmessage = (event) => wrapper.onmessage?.(event.data);
+      return wrapper;
+    },
+    role,
+    rtcChannelsSupported: () => role === "follower" && typeof RTCPeerConnection === "function",
+    serverCallsInLeader: true,
+    viewingRequiresFocus: true,
+    files,
+    leaderUnavailable: () => bridge.info?.another_instance ? { code: "invalid_state", details: { reason: "another_instance" } } : { code: "engine_unavailable", details: { reason: engineState === "ready" ? "starting" : engineState } },
+    prepareForward: async (_method, args) => await blobsToPaths(args, (blob, name) => files.writeBlobTemp(blob, name)),
+    extendClient: (h) => {
+      host = h;
+      return opts.extend(h);
+    }
+  };
+  return {
+    platform,
+    engineKv,
+    windowKv,
+    files,
+    host: () => {
+      if (!host) throw new Error("客户端还没有创建");
+      return host;
+    },
+    setEngineState: (state) => {
+      engineState = state;
+    }
+  };
+}
+function pageLifecycle() {
+  const win = typeof window !== "undefined" ? window : void 0;
+  return {
+    onPageHide: (listener) => {
+      if (!win) return () => {
+      };
+      const handler = () => listener(false);
+      win.addEventListener("pagehide", handler);
+      return () => win.removeEventListener("pagehide", handler);
+    },
+    onPageShow: () => () => {
+    },
+    onFreeze: () => () => {
+    },
+    onResume: () => () => {
+    }
+  };
+}
+function cryptoRandom() {
+  const c = globalThis.crypto;
+  return {
+    uuid: () => c.randomUUID(),
+    bytes: (n) => {
+      const out = new Uint8Array(n);
+      c.getRandomValues(out);
+      return out;
+    },
+    float: () => Math.random()
+  };
+}
+function wrapWebSocket(ws) {
+  const wrapper = {
+    get readyState() {
+      return ws.readyState;
+    },
+    send: (data) => ws.send(data),
+    close: (code, reason) => ws.close(code, reason),
+    onopen: null,
+    onmessage: null,
+    onclose: null,
+    onerror: null
+  };
+  ws.onopen = () => wrapper.onopen?.();
+  ws.onmessage = (event) => {
+    if (typeof event.data === "string") wrapper.onmessage?.(event.data);
+  };
+  ws.onclose = (event) => wrapper.onclose?.(event.code, event.reason);
+  ws.onerror = () => wrapper.onerror?.();
+  return wrapper;
+}
+
+// src/version.ts
+var TAURI_SDK_VERSION = "1.0.0-alpha" ;
+var PROTOCOL_VERSION = 1;
+var ENGINE_LABEL = "deeprespond-im-engine";
+var PLUGIN = "plugin:deeprespond-im|";
+var tauriTransport = {
+  invoke: (cmd, args, options) => invoke(cmd, args, options),
+  channel: (onEvent) => {
+    const channel = new Channel();
+    channel.onmessage = onEvent;
+    return channel;
+  }
+};
+function currentLabel() {
+  if (!isTauri()) return null;
+  const internals = globalThis.__TAURI_INTERNALS__;
+  return internals?.metadata?.currentWebview?.label ?? internals?.metadata?.currentWindow?.label ?? null;
+}
+function toError(err, command) {
+  if (err instanceof DRError) return err;
+  if (err && typeof err === "object" && typeof err.code === "string") {
+    const e = err;
+    const details = {};
+    if (e.reason) details.reason = e.reason;
+    return new DRError({ code: e.code, message: e.message ?? e.code, details, source: "local" });
+  }
+  const text = typeof err === "string" ? err : err instanceof Error ? err.message : String(err);
+  if (/not allowed|denied|ACL|capabilit/i.test(text)) {
+    return new DRError({ code: "permission_denied", message: text, details: { reason: "capability_missing", command }, source: "local" });
+  }
+  return new DRError({ code: "invalid_state", message: text, details: { reason: "plugin", command }, source: "local" });
+}
+var Bridge = class _Bridge {
+  static #instance = null;
+  static get() {
+    if (!_Bridge.#instance) _Bridge.#instance = new _Bridge(currentLabel() ?? "");
+    return _Bridge.#instance;
+  }
+  /** 测试用：指定本页面的连接（假的插件）。 */
+  static use(bridge) {
+    _Bridge.#instance = bridge;
+  }
+  label;
+  isEngine;
+  ready;
+  #info = null;
+  #listeners = /* @__PURE__ */ new Map();
+  #transport;
+  constructor(label, transport = tauriTransport) {
+    this.label = label;
+    this.isEngine = label === ENGINE_LABEL;
+    this.#transport = transport;
+    const channel = transport.channel((event) => this.#dispatch(event));
+    this.ready = (async () => {
+      let info;
+      try {
+        info = await transport.invoke(`${PLUGIN}hello`, { js_version: TAURI_SDK_VERSION, protocol: PROTOCOL_VERSION, channel });
+      } catch (err) {
+        throw toError(err, "hello");
+      }
+      if (info.plugin_version !== TAURI_SDK_VERSION || info.protocol !== PROTOCOL_VERSION) {
+        throw new DRError({
+          code: "unsupported",
+          message: `@deeprespond/im-tauri ${TAURI_SDK_VERSION} 与 tauri-plugin-deeprespond-im ${info.plugin_version} 的版本不同`,
+          details: { reason: "version_mismatch", js_version: TAURI_SDK_VERSION, plugin_version: info.plugin_version },
+          source: "local"
+        });
+      }
+      this.#info = info;
+      return info;
+    })();
+    this.ready.catch(() => {
+    });
+  }
+  /** hello 之后的信息；之前为 null。 */
+  get info() {
+    return this.#info;
+  }
+  /** 调用插件命令（等 hello 完成）。 */
+  async call(command, args) {
+    await this.ready;
+    try {
+      return await this.#transport.invoke(`${PLUGIN}${command}`, args);
+    } catch (err) {
+      throw toError(err, command);
+    }
+  }
+  /** 原始字节的请求体（Blob 落盘），参数放在请求头中。 */
+  async callRaw(command, body, headers) {
+    await this.ready;
+    try {
+      return await this.#transport.invoke(`${PLUGIN}${command}`, body, { headers });
+    } catch (err) {
+      throw toError(err, command);
+    }
+  }
+  on(type, listener) {
+    let set = this.#listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(type, set);
+    }
+    set.add(listener);
+    return () => set?.delete(listener);
+  }
+  #dispatch(event) {
+    if (!event || typeof event.t !== "string") return;
+    for (const listener of [...this.#listeners.get(event.t) ?? []]) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.warn(`[im] 处理插件事件出错：${event.t}`, err);
+      }
+    }
+    for (const listener of [...this.#listeners.get("*") ?? []]) listener(event);
+  }
+};
+function makeLogger(bridge, option) {
+  const pending = [];
+  let timer = null;
+  const flush = () => {
+    timer = null;
+    const entries = pending.splice(0);
+    if (entries.length > 0) void bridge.call("log_write", { entries }).catch(() => {
+    });
+  };
+  return {
+    level: option?.level,
+    sink: (entry) => {
+      if (option?.sink) {
+        try {
+          option.sink(entry);
+        } catch {
+        }
+      } else if (entry.level === "error" || entry.level === "warn") {
+        const print = entry.level === "error" ? console.error : console.warn;
+        print(`[im] ${entry.module}: ${entry.message}`, entry.code ?? "", entry.reason ?? "");
+      }
+      if (!bridge.info?.log_file) return;
+      pending.push(entry);
+      if (pending.length > 500) pending.splice(0, pending.length - 500);
+      if (timer === null) timer = setTimeout(flush, 1e3);
+    }
+  };
+}
+function clickEvent(bridge, event) {
+  const clickId = String(event.click_id ?? "");
+  let claimed = false;
+  const out = {
+    id: String(event.id ?? ""),
+    kind: event.kind ?? "custom",
+    launched: event.launched === true,
+    claim: () => {
+      if (claimed || !clickId) return;
+      claimed = true;
+      void bridge.call("notify_claim", { click_id: clickId }).catch(() => {
+      });
+    }
+  };
+  if (typeof event.conversation_id === "string") out.conversation_id = event.conversation_id;
+  if (typeof event.seq === "number") out.seq = event.seq;
+  if (typeof event.action === "string") out.action = event.action;
+  if (event.data && typeof event.data === "object") out.data = event.data;
+  return Object.freeze(out);
+}
+function unsupported(reason, message) {
+  return new DRError({ code: "unsupported", message, details: { reason }, source: "local" });
+}
+function invalidState(reason) {
+  return new DRError({ code: "invalid_state", message: reason, details: { reason }, source: "local" });
+}
+function validation(reason, field) {
+  return new DRError({ code: "local_validation", message: reason, details: { reason, field }, source: "local" });
+}
+var Desktop = class {
+  constructor(bridge, client) {
+    this.bridge = bridge;
+    this.#client = client;
+    Object.preventExtensions(this);
+  }
+  bridge;
+  #client;
+  #seq = 0;
+  async notify(n) {
+    if (!n || typeof n.title !== "string" || typeof n.body !== "string") throw validation("required", "title");
+    if (n.id !== void 0 && (typeof n.id !== "string" || n.id.startsWith("dr:"))) throw validation("reserved_id", "id");
+    if (n.data !== void 0) {
+      if (typeof n.data !== "object" || Object.values(n.data).some((v) => typeof v !== "string")) throw validation("invalid_type", "data");
+      if (new TextEncoder().encode(JSON.stringify(n.data)).length > 1024) throw validation("too_large", "data");
+    }
+    if (n.actions && (n.actions.length > 2 || n.actions.some((a) => typeof a?.id !== "string" || typeof a.title !== "string"))) throw validation("invalid_value", "actions");
+    await this.show({ ...n, id: n.id ?? `app:${Date.now().toString(36)}:${++this.#seq}`, kind: "custom" });
+  }
+  /** SDK 自己显示的通知（id 以 dr: 开头）。 */
+  async show(n) {
+    await this.bridge.call("notify_show", {
+      id: n.id,
+      title: n.title,
+      body: n.body,
+      kind: n.kind,
+      conversation_id: n.conversation_id ?? null,
+      seq: n.seq ?? null,
+      data: n.data ?? null,
+      sound: n.sound !== false,
+      actions: n.actions ?? null,
+      group: n.group ?? n.conversation_id ?? null
+    });
+  }
+  async clearNotifications(p = {}) {
+    await this.bridge.call("notify_clear", p.conversation_id ? { conversation_id: p.conversation_id } : { all: true });
+  }
+  /** 清除一条（来电被处理后）。 */
+  async clear(id) {
+    await this.bridge.call("notify_clear", { id });
+  }
+  notificationPermission() {
+    return this.bridge.call("notify_permission");
+  }
+  requestNotificationPermission() {
+    return this.bridge.call("notify_request_permission");
+  }
+  async setBadge(count) {
+    if (count !== null && (!Number.isInteger(count) || count < 0)) throw validation("invalid_value", "count");
+    await this.bridge.call("badge_set", { count });
+  }
+  async requestAttention(p = {}) {
+    await this.bridge.call("attention_request", { critical: p.critical === true, label: this.bridge.isEngine ? null : this.bridge.label });
+  }
+  async trayBlink(p) {
+    if (p === null) {
+      await this.bridge.call("tray_blink", { blink: null });
+      return;
+    }
+    if (typeof p.trayId !== "string" || !Array.isArray(p.icons) || p.icons.length !== 2) throw validation("invalid_value", "icons");
+    await this.bridge.call("tray_blink", { blink: { tray_id: p.trayId, icons: p.icons, interval_ms: p.intervalMs ?? 500 } });
+  }
+  pickFiles(p = {}) {
+    return this.bridge.call("files_pick", { multiple: p.multiple === true, filters: p.filters ?? null });
+  }
+  pickSavePath(p = {}) {
+    return this.bridge.call("files_pick_save", { default_name: p.defaultName ?? null });
+  }
+  fileUrl(path) {
+    if (typeof path !== "string" || path === "") throw validation("required", "path");
+    return fileUrl(path, this.info.os);
+  }
+  /**
+   * 由 Rust 下载到磁盘（《2.功能概述文档》第 9.4 节）：文件地址先换取下载地址（界面窗口中经引擎）；
+   * 地址过期（403）时重新换取后续传。
+   */
+  download(source, p = {}) {
+    const task = newTask("down");
+    const controller = new AbortController();
+    if (p.signal) {
+      if (p.signal.aborted) controller.abort();
+      else p.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    const run = async () => {
+      let url;
+      let name;
+      if (typeof source === "string") {
+        url = source;
+      } else {
+        const body = source?.message?.body ?? {};
+        if (typeof body.url !== "string" || body.url === "") throw validation("required", "message.body.url");
+        url = body.url;
+        if (typeof body.name === "string") name = body.name;
+      }
+      const client = this.#client();
+      const isFile = client.files.isFileUrl(url);
+      const resolve = async () => isFile ? (await client.files.resolveUrl(url)).download_url : url;
+      const off = this.bridge.on("download_progress", (event) => {
+        if (event.task === task && typeof event.loaded === "number") p.onProgress?.(event.loaded, typeof event.total === "number" ? event.total : null);
+      });
+      const onAbort = () => void this.bridge.call("files_cancel", { task }).catch(() => {
+      });
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        let target = await resolve();
+        for (let attempt = 0; ; attempt++) {
+          if (controller.signal.aborted) throw new DRError({ code: "aborted", message: "aborted", source: "local" });
+          try {
+            return await this.bridge.call("files_download", { task, url: target, dest: p.saveTo ?? null, conflict: p.conflict ?? "rename", name: name ?? null });
+          } catch (err) {
+            if (err instanceof DRError && err.code === "url_expired" && isFile && attempt < 2) {
+              target = await resolve();
+              continue;
+            }
+            throw err;
+          }
+        }
+      } finally {
+        off();
+        controller.signal.removeEventListener("abort", onAbort);
+      }
+    };
+    const promise = run();
+    promise.cancel = () => controller.abort();
+    return promise;
+  }
+  async openPath(path) {
+    await this.bridge.call("files_open", { path });
+  }
+  async revealPath(path) {
+    await this.bridge.call("files_reveal", { path });
+  }
+  async exportDiagnostics(p = {}) {
+    const client = this.#client();
+    let diagnostics = null;
+    try {
+      diagnostics = client.connection.getDiagnostics();
+    } catch {
+    }
+    return this.bridge.call("diagnostics_export", { save_to: p.saveTo ?? null, info: { label: this.bridge.label, sdk_version: TAURI_SDK_VERSION, desktop: this.info, diagnostics } });
+  }
+  get info() {
+    const info = this.bridge.info;
+    let calls = false;
+    try {
+      calls = this.#client().calls.supported;
+    } catch {
+      calls = false;
+    }
+    return Object.freeze({
+      os: info?.os ?? osFromUserAgent(typeof navigator !== "undefined" ? navigator.userAgent : ""),
+      os_version: info?.os_version ?? "",
+      webview_version: info?.webview_version ?? "",
+      sdk_version: TAURI_SDK_VERSION,
+      calls_supported: calls
+    });
+  }
+};
+
+export { Bridge, Desktop, ENGINE_LABEL, TAURI_SDK_VERSION, clickEvent, createTauriPlatform, currentLabel, invalidState, makeLogger, osFromUserAgent, unsupported };
+//# sourceMappingURL=chunk-DMEEI2YZ.js.map
+//# sourceMappingURL=chunk-DMEEI2YZ.js.map