{
  "payload": {
    "version": "1.2.0",
    "protocol": "zhuge-im-v1",
    "api_major": 1,
    "storage_version": 1,
    "files": {
      "bootstrap.js": "7635493d28fcbfb0188db95596cb7177be9eda49d19ea944198eb308bd964713",
      "build.mjs": "45feb781439cc3de4b2ff7d497ad1972cefc4a76dfa403b81ca6810656b75c1f",
      "config.js": "36946cf75ff79b62e6606147425b58d10dc11df2cff31d39b9508135b2a30411",
      "extension-host.js": "f80651e554a3c39e106420b8acabe159f6afaf55f1c2ffcecd48705a27a2ceab",
      "extension-schema.js": "5ce6a6d9c2f857ff57712974f7832872d0093f4b3944a022cba8dedbc3a6a214",
      "extension-worker.js": "3159ffbc7b7ca6099308b8161acfeef0839113321bb13ad0cb34953525d4fc02",
      "extensions-page.js": "2da43a47c8e7df6ecf05b239f2f214fbb7b1a63d6b4103183301c3ef51221f9a",
      "guard.mjs": "edd71cb2b6f6a729bc123649dba2201531145ba8fadb32c80c20ddceeb2413fe",
      "guest-control.js": "34dd9e419148bd90ac1991ba63b7a3c5765bc4f6192ab8982eb72f7e99dc77fd",
      "guest-identity.js": "7fbde6606f7e2930b6e787fce1c9ccd20a6187aed80ee4e4f5bf87d0849f40f7",
      "integrity.js": "19a593743549d4963b15d1b28cd85162687b46ed84b778becb2adf71682ad8d1",
      "recovery.html": "a56c1f38279f9e4614403332d9fafef47a779778d166da9e6991313f04f82818",
      "recovery.js": "759f3c2549a71684707cb8c1bcd2cdb12f8355aa43cf6a774e258816eb7ccca9",
      "release-key.json": "fac5a606b5a942538f373ca29639d998405f0b794a323c8577c8a55456906962",
      "sdk.js": "dde24a19e63aee8eed034f50a939458201cd818c8543b3a743e36cf5f89fa36a",
      "server.mjs": "2dc5501bdf0976170cf2ba3ce49427d5b20cb9ece89047f8e2a9a284ecde12b0",
      "src/client.ts": "c6ca01f4191025bed479d19e07165ff9cda57bc1b3b92b06912a09a33e387ed2",
      "src/client.js": "5801686b1b5fee24daaaf0e2bd5fb02549adfbeb9a3b2f0c68e7097197931272",
      "src/storage.ts": "f862ad2af24bc9443cf56943c18490fee49e760e50e0305f8bece6d2a2713a0b",
      "src/storage.js": "42ec41b51d55927a7304cad179470bf0a2996c260ed3dfffc20692ca4b976290"
    },
    "baseline": {
      "bootstrap.js": "Ly8gVmVyaWZ5IGJlZm9yZSBpbXBvcnRpbmcgdGhlIGNvbW11bmljYXRpb24gbW9kdWxlLCBpbmNsdWRpbmcgb24gc3RhdGljIEhUVFBTIGhvc3RpbmcuCmNvbnN0IG5vdGljZT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbm90aWNlJyksY29ubmVjdD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29ubmVjdCcpOwpjb25uZWN0LmRpc2FibGVkPXRydWU7bm90aWNlLnRleHRDb250ZW50PSfmraPlnKjmo4Dmn6XpgJrkv6HnqIvluo/igKYnOwp0cnl7Y29uc3Qge2NoZWNrQ29yZX09YXdhaXQgaW1wb3J0KCcuL2ludGVncml0eS5qcycpO2F3YWl0IGNoZWNrQ29yZSgpO2F3YWl0IGltcG9ydCgnLi9hcHAuanMnKTtjb25uZWN0LmRpc2FibGVkPWZhbHNlO30KY2F0Y2goZXJyb3Ipe25vdGljZS50ZXh0Q29udGVudD1g56iL5bqP5qOA5p+l5pyq5a6M5oiQ77yaJHtlcnJvci5tZXNzYWdlfeOAguivt+aJk+W8gOKAnOajgOafpeS4juaBouWkjeKAne+8jOaIlumHjeaWsOS4i+i9veWujOaVtOWPr+WumuWItueJiOOAgmA7Y29ubmVjdC5kaXNhYmxlZD10cnVlO30K",
      "build.mjs": "aW1wb3J0IHRzIGZyb20gJ3R5cGVzY3JpcHQnOwppbXBvcnQge3JlYWRGaWxlLHdyaXRlRmlsZX0gZnJvbSAnbm9kZTpmcy9wcm9taXNlcyc7CmlmKCFwcm9jZXNzLmFyZ3YuaW5jbHVkZXMoJy0tZXhwZXJpbWVudGFsJykpdGhyb3cgbmV3IEVycm9yKCfnm7TmjqXnvJbor5HkvJrmlLnlj5jlj5fkv53miqTnmoTpgJrkv6HmoLjlv4PjgILor7flhYjov5DooYwgbm9kZSBndWFyZC5tanMgZXhwZXJpbWVudO+8jOWcqOWunumqjOWJr+acrOS4reS9v+eUqCAtLWV4cGVyaW1lbnRhbO+8m+WunumqjOeJiOS4jeiDveWGkuWFheWumOaWueeJiOacrOOAgicpOwpmb3IoY29uc3QgbmFtZSBvZiBbJ2NsaWVudCcsJ3N0b3JhZ2UnXSl7CiAgY29uc3Qgc291cmNlPWF3YWl0IHJlYWRGaWxlKG5ldyBVUkwoYHNyYy8ke25hbWV9LnRzYCxpbXBvcnQubWV0YS51cmwpLCd1dGY4Jyk7CiAgY29uc3QgcmVzdWx0PXRzLnRyYW5zcGlsZU1vZHVsZShzb3VyY2Use2NvbXBpbGVyT3B0aW9uczp7dGFyZ2V0OnRzLlNjcmlwdFRhcmdldC5FUzIwMjIsbW9kdWxlOnRzLk1vZHVsZUtpbmQuRVMyMDIyfX0pOwogIGF3YWl0IHdyaXRlRmlsZShuZXcgVVJMKGBzcmMvJHtuYW1lfS5qc2AsaW1wb3J0Lm1ldGEudXJsKSxyZXN1bHQub3V0cHV0VGV4dC5yZXBsYWNlKC9mcm9tICJcLlwvc3RvcmFnZSIvZywnZnJvbSAiLi9zdG9yYWdlLmpzIicpKTsKfQo=",
      "config.js": "Ly8gUHVibGljIHBsYXRmb3JtIGFkZHJlc3Mgb25seS4gTmV2ZXIgcHV0IGFuIGFjY2VzcyB0b2tlbiBpbiB0aGlzIGZpbGUuCmV4cG9ydCBjb25zdCBwbGF0Zm9ybU9yaWdpbiA9ICdodHRwczovL3podWdlanVuc2hpLmNvbSc7Cg==",
      "extension-host.js": "import {validateExtension,extensionDigest} from './extension-schema.js';
import {platformOrigin} from './config.js';
export const EXTENSION_KEY='zhuge-direct-im-extensions-v1';
export function installedExtensions(){try{const v=JSON.parse(localStorage.getItem(EXTENSION_KEY)||'[]');return Array.isArray(v)?v.slice(0,20):[];}catch{return [];}}
export async function readExtension(record){
  if(typeof record?.text!=='string'||record.text.length>65536)throw new Error('扩展文件无效。');
  const extension=validateExtension(JSON.parse(record.text));
  const digest=await extensionDigest(record.text);
  if(record.digest!==digest)throw new Error('扩展内容已经变化，请重新导入并授权。');
  return {extension,digest};
}
export async function checkMarketRecord(record){
  if(!record.release_id)return;
  if(!/^[a-f0-9]{32}$/.test(record.release_id))throw new Error('扩展来源无效。');
  const response=await fetch(`${platformOrigin}/api/im-direct/extensions/catalog/${record.release_id}`,{credentials:'omit',cache:'no-store',signal:AbortSignal.timeout(8000)});
  if(!response.ok)throw new Error('该版本暂不可用，请到扩展市场查看。');
  const release=await response.json();if(release.sha256!==record.digest||release.status!=='approved')throw new Error('该版本已变更或停止分发。');
}
export function mountExtensions(root,{getDraft,setDraft,getContext,notice}){
  let generation=0,workers=new Set();
  const element=(tag,text)=>{const el=document.createElement(tag);if(text!==undefined)el.textContent=text;return el;};
  const reset=()=>{generation++;for(const w of workers)w.terminate();workers.clear();root.replaceChildren();};
  async function render(){
    reset();const epoch=generation;const context=getContext();
    if(!context){root.textContent='打开聊天并选择会话后，可启用已安装的扩展。';return;}
    const items=installedExtensions();if(!items.length){root.textContent='尚未安装扩展，可从“管理我的扩展”添加。';return;}
    for(const record of items){
      try{
        const {extension:e}=await readExtension(record);if(epoch!==generation)return;
        const row=element('div');row.className='extension-row';
        row.append(element('p',`${e.name} · ${e.version} · ${record.release_id?'市场版本':'本地修改版'}`));
        const consent=element('input');consent.type='checkbox';
        const label=element('label');label.append(consent,document.createTextNode(` 本次连接允许：${e.permissions.map(p=>p==='draft.read'?'读取当前草稿':'经我操作写入草稿').join('、')||'仅生成预览'}。`));row.append(label);
        const buttons=element('div');buttons.className='tools';
        const output=element('textarea');output.readOnly=true;output.rows=3;output.setAttribute('aria-label',`${e.name}处理结果`);
        const apply=element('button','放入草稿');apply.disabled=true;
        let resultContext='',run=0;
        const isCurrent=()=>epoch===generation&&getContext()===context&&installedExtensions().some(r=>r.digest===record.digest&&r.text===record.text);
        consent.onchange=()=>{run++;output.value='';apply.disabled=true;};
        for(const action of e.actions){
          const button=element('button',action.label);buttons.append(button);
          let quantity,price,shipping;
          if(action.operation==='quote'){
            const fields=element('div');fields.className='tools';
            for(const [name,title,initial] of [['quantity','数量','1'],['price','单价','0'],['shipping','运费','0']]){
              const input=element('input');input.type='number';input.min=name==='quantity'?'1':'0';input.step=name==='quantity'?'1':'.01';input.value=initial;input.setAttribute('aria-label',title);input.style.width='130px';const l=element('label',title+' ');l.append(input);fields.append(l);
              if(name==='quantity')quantity=input;else if(name==='price')price=input;else shipping=input;
            }row.append(fields);
          }
          button.onclick=async()=>{
            const attempt=++run;apply.disabled=true;output.value='';
            if(!consent.checked||!isCurrent()){notice('请先启用本次连接所需的扩展权限。');return;}
            button.disabled=true;let worker,timer;
            try{
              await readExtension(record);await checkMarketRecord(record);
              if(attempt!==run||!consent.checked||!isCurrent())throw new Error('扩展已停止，未读取草稿。');
              const input={};if(e.permissions.includes('draft.read'))input.draft=getDraft();
              if(quantity)Object.assign(input,{quantity:Number(quantity.value),price:Number(price.value),shipping:Number(shipping.value)});
              worker=new Worker(new URL('./extension-worker.js',import.meta.url),{type:'module'});workers.add(worker);
              const result=await new Promise((resolve,reject)=>{timer=setTimeout(()=>reject(new Error('扩展处理超时。')),2000);worker.onerror=()=>reject(new Error('扩展处理失败。'));worker.onmessage=event=>{if(event.data.id!==attempt)return;event.data.error?reject(new Error(event.data.error)):resolve(event.data.result);};worker.postMessage({id:attempt,extension:e,action:action.id,input});});
              if(attempt!==run||!consent.checked||!isCurrent())throw new Error('会话或授权已改变，未写入草稿。');
              if(typeof result!=='string'||result.length>4000)throw new Error('扩展返回内容无效。');
              output.value=result;resultContext=context;apply.disabled=!e.permissions.includes('draft.write');
            }catch(error){notice(error.message);}finally{clearTimeout(timer);if(worker){worker.terminate();workers.delete(worker);}button.disabled=false;}
          };
        }
        apply.onclick=()=>{if(!consent.checked||!isCurrent()||resultContext!==getContext()||!e.permissions.includes('draft.write')){notice('授权或会话已改变，请重新处理。');apply.disabled=true;return;}setDraft(output.value);notice('已放入草稿，请检查后自行发送。');apply.disabled=true;};
        row.append(buttons,output,apply);root.append(row);
      }catch(error){root.append(element('p',error.message));}
    }
  }
  return {render,reset};
}
",
      "extension-schema.js": "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",
      "extension-worker.js": "aW1wb3J0IHtleGVjdXRlQWN0aW9ufSBmcm9tICcuL2V4dGVuc2lvbi1zY2hlbWEuanMnOwovLyBPbmx5IHRoaXMgdHJ1c3RlZCBpbnRlcnByZXRlciBydW5zLiBFeHRlbnNpb24gZG9jdW1lbnRzIGFyZSBuZXZlciBldmFsdWF0ZWQgYXMgY29kZS4Kc2VsZi5vbm1lc3NhZ2U9ZXZlbnQ9PnsKICB0cnl7c2VsZi5wb3N0TWVzc2FnZSh7aWQ6ZXZlbnQuZGF0YS5pZCxyZXN1bHQ6ZXhlY3V0ZUFjdGlvbihldmVudC5kYXRhLmV4dGVuc2lvbixldmVudC5kYXRhLmFjdGlvbixldmVudC5kYXRhLmlucHV0KX0pO30KICBjYXRjaChlcnJvcil7c2VsZi5wb3N0TWVzc2FnZSh7aWQ6ZXZlbnQuZGF0YT8uaWQsZXJyb3I6ZXJyb3IubWVzc2FnZX0pO30KfTsK",
      "extensions-page.js": "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",
      "guard.mjs": "import {readFile,writeFile,mkdir,rename,lstat,copyFile,readdir} from 'node:fs/promises';
import {createHash,createPublicKey,verify,randomUUID} from 'node:crypto';
import path from 'node:path';
import {fileURLToPath} from 'node:url';
const sha=data=>createHash('sha256').update(data).digest('hex');
export const root=fileURLToPath(new URL('.',import.meta.url));
const required=['bootstrap.js','sdk.js','integrity.js','config.js','server.mjs','guard.mjs','extension-host.js','extension-schema.js','extension-worker.js','src/client.js','src/storage.js'];
const validPath=name=>/^(?:src\/[a-z-]+\.(?:js|ts)|[a-z-]+\.(?:js|mjs|json|html))$/.test(name);
async function safeTarget(base,name){
  if(!validPath(name))throw new Error('核心文件路径无效。');
  const target=path.resolve(base,name);if(!target.startsWith(path.resolve(base)+path.sep))throw new Error('核心路径越界。');
  let current=base;for(const part of name.split('/')){current=path.join(current,part);const stat=await lstat(current).catch(e=>{if(e.code==='ENOENT')return null;throw e;});if(stat?.isSymbolicLink())throw new Error('核心路径不能使用符号链接。');}
  return target;
}
export async function verifyRelease(release,base=root){
  const trustedKey=await readFile(path.join(base,'release-key.json'));
  const jwk=JSON.parse(trustedKey.toString());
  if(!release?.payload||typeof release.signature!=='string'||!verify('RSA-SHA256',Buffer.from(JSON.stringify(release.payload)),createPublicKey({key:jwk,format:'jwk'}),Buffer.from(release.signature,'base64')))throw new Error('核心发布签名无效。');
  const p=release.payload;
  if(p.files?.['release-key.json']!==sha(trustedKey))throw new Error('升级文件不能静默替换官方签名根。');
  if(p.protocol!=='zhuge-im-v1'||p.api_major!==1||p.storage_version!==1||!/^\d+\.\d+\.\d+$/.test(p.version))throw new Error('协议或本地记录格式不兼容，不能直接切换此版本。');
  if(!p.files||!p.baseline||Object.keys(p.files).length>40||required.some(n=>!p.files[n]))throw new Error('核心发布清单不完整。');
  for(const [name,digest] of Object.entries(p.files)){
    if(!validPath(name)||typeof p.baseline[name]!=='string'||p.baseline[name].length>2000000||sha(Buffer.from(p.baseline[name],'base64'))!==digest)throw new Error('核心恢复内容校验失败。');
  }
  return p;
}
export async function check(base=root){
  const release=JSON.parse(await readFile(path.join(base,'release.json'),'utf8'));const p=await verifyRelease(release,base);const changed=[];
  for(const [name,digest] of Object.entries(p.files)){
    try{if(sha(await readFile(await safeTarget(base,name)))!==digest)changed.push(name);}catch{changed.push(name);}
  }
  return {ok:changed.length===0,version:p.version,protocol:p.protocol,changed};
}
export async function restore(release,base=root){
  const p=await verifyRelease(release,base);
  const targets=[];for(const name of Object.keys(p.files))targets.push([name,await safeTarget(base,name),Buffer.from(p.baseline[name],'base64')]);
  targets.push(['release.json',await safeTarget(base,'release.json'),Buffer.from(JSON.stringify(release,null,2))]);
  const backupRoot=path.join(base,'user-backups');const st=await lstat(backupRoot).catch(()=>null);if(st?.isSymbolicLink())throw new Error('备份目录不能使用符号链接。');
  const backup=path.join(backupRoot,`core-${Date.now()}-${randomUUID()}`);await mkdir(backup,{recursive:true});
  // Back up every existing core file before the first mutation; never touch browser storage.
  for(const [name,target] of targets){const content=await readFile(target).catch(e=>{if(e.code==='ENOENT')return null;throw e;});if(content){const dest=path.join(backup,name);await mkdir(path.dirname(dest),{recursive:true});await writeFile(dest,content,{flag:'wx'});}}
  for(const [,target,bytes] of targets){await mkdir(path.dirname(target),{recursive:true});const staged=target+'.'+randomUUID()+'.tmp';await writeFile(staged,bytes,{flag:'wx'});await rename(staged,target);}
  return {version:p.version,backup,check:await check(base)};
}
export async function update(release,base=root){
  const current=await check(base);if(!current.ok)throw new Error('请先恢复当前核心，再检查升级。');
  const p=await verifyRelease(release,base);const next=p.version.split('.').map(Number),old=current.version.split('.').map(Number);
  const differing=next.findIndex((n,i)=>n!==old[i]);if(differing>=0&&next[differing]<old[differing])throw new Error('不能直接降级核心；请保留当前数据并使用原版本备份。');
  return restore(release,base);
}
async function experiment(base=root){
  const parent=path.join(base,'experiments');if((await lstat(parent).catch(()=>null))?.isSymbolicLink())throw new Error('实验目录不能使用符号链接。');
  const dest=path.join(parent,`core-${Date.now()}-${randomUUID()}`);await mkdir(dest,{recursive:true});
  async function copy(from,to){for(const item of await readdir(from,{withFileTypes:true})){if(item.name.startsWith('.')||['experiments','user-backups','node_modules'].includes(item.name)||item.isSymbolicLink())continue;const s=path.join(from,item.name),t=path.join(to,item.name);if(item.isDirectory()){await mkdir(t,{recursive:true});await copy(s,t);}else if(item.isFile())await copyFile(s,t);}}
  await copy(base,dest);return {path:dest,message:'实验副本已创建。请使用不同端口、独立浏览器配置和测试账号；浏览器记录没有复制。'};
}
if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
  try{const command=process.argv[2]||'check';let result;
    if(command==='check')result=await check();
    else if(command==='restore')result=await restore(JSON.parse(await readFile(path.join(root,'release.json'),'utf8')));
    else if(command==='update'&&process.argv[3])result=await update(JSON.parse(await readFile(process.argv[3],'utf8')));
    else if(command==='experiment')result=await experiment();
    else throw new Error('使用 node guard.mjs check / restore / update 发布文件 / experiment。');
    console.log(JSON.stringify(result,null,2));if(result.ok===false)process.exitCode=1;
  }catch(error){console.error('检查未完成：'+error.message);process.exitCode=1;}
}
",
      "guest-control.js": "import {platformOrigin} from './config.js';
import {openDevice,readDevice,saveDevice,hash,numberFor,sign,verify,base64,seal,unseal} from './guest-identity.js';

export async function validateRoom(envelope,ownId,complete=true){
  const room=JSON.parse(envelope.payload),seen=new Set();
  if(room.version!==1||Object.keys(room).sort().join()!=='members,nonce,owner,title,version'||typeof room.nonce!=='string'||room.nonce.length!==36||typeof room.title!=='string'||room.title.length>40||!room.title.trim()||!Array.isArray(room.members)||room.members.length<2||room.members.length>6)throw new Error('会话信息不正确。');
  for(const m of room.members){
    if(Object.keys(m).sort().join()!=='id,name,public_key'||m.id!==await numberFor(m.public_key)||typeof m.name!=='string'||!m.name.trim()||m.name.length>40||seen.has(m.id))throw new Error('设备身份不一致。');
    seen.add(m.id);const signature=envelope.signatures[String(m.id)];
    if((complete||signature)&&!await verify(m.public_key,'zhuge-im-room-v1\n'+envelope.payload,signature))throw new Error('成员未确认或签名已变化。');
  }
  if(!seen.has(ownId)||!seen.has(room.owner)||Object.keys(envelope.signatures).some(id=>!seen.has(Number(id))))throw new Error('不属于这个会话。');
  const digest=await hash(envelope.payload);return {...room,digest,id:parseInt(digest.slice(0,13),16)||1,envelope};
}

export class GuestControl{
  static async create(name,alias,onChange,onNotice){const self=new GuestControl();self.identity=await openDevice(name,alias);self.onChange=onChange;self.onNotice=onNotice;await self.loadRooms();return self;}
  token='';expires=0;discoverable=true;autoPauseArmed=true;closed=false;rooms=[];invitations=[];links=[];connectedIds=new Set();lastPresence=0;pageId='';
  async loadRooms(){this.rooms=[];for(const e of this.identity.rooms||[]){const room=await validateRoom(e,this.identity.id);if(!room.members.some(m=>this.identity.blocked.includes(m.id)))this.rooms.push(room);}}
  profile(){return {id:this.identity.id,name:this.identity.name,alias:this.identity.alias,discoverable:this.discoverable};}
  conversations(){return this.rooms.map(r=>({id:r.id,title:r.members.length===2?r.members.find(m=>m.id!==this.identity.id).name:r.title,conversation_type:r.members.length===2?'direct':'group',participants:r.members.map(m=>({user_id:m.id,display_name:m.name}))}));}
  trusted(peer,id){return !this.closed&&!this.identity.blocked.includes(peer)&&this.rooms.some(r=>r.id===id&&r.members.some(m=>m.id===peer)&&r.members.some(m=>m.id===this.identity.id));}
  connected(ids){
    this.connectedIds=new Set(ids);
    const expected=[...new Set(this.rooms.flatMap(r=>r.members.map(m=>m.id)))].filter(id=>id!==this.identity.id);
    const all=expected.length&&expected.every(id=>this.connectedIds.has(id));
    if(!all)this.autoPauseArmed=true;
    if(this.discoverable&&all&&this.autoPauseArmed&&!this.invitations.some(i=>!i.declined&&!i.complete))void this.discovery(false).catch(e=>this.onNotice(e.message));
  }
  async http(path,body,authenticated=true){
    if(this.closed)throw new Error('设备连接已结束。');
    if(authenticated&&this.expires<Date.now())await this.authenticate();
    const r=await fetch(`${platformOrigin}/api/im-direct/guest${path}`,{method:'POST',credentials:'omit',cache:'no-store',headers:{'Content-Type':'application/json',...(authenticated?{Authorization:`Bearer ${this.token}`}:{})},body:JSON.stringify(body),signal:AbortSignal.timeout(12000)});
    const data=await r.json().catch(()=>({}));if(!r.ok){if(r.status===401)this.expires=0;throw new Error(typeof data.detail==='string'?data.detail:`设备发现暂未完成（${r.status}）。`);}return data;
  }
  async authenticate(){
    const c=await this.http('/challenge',{public_key:this.identity.public_key},false);
    if(c.id!==this.identity.id)throw new Error('设备联系号不匹配。');
    const signature=await sign(this.identity,'zhuge-im-guest-session-v1\n'+c.challenge+'\n'+location.origin);
    const session=await this.http('/session',{public_key:this.identity.public_key,challenge:c.challenge,signature},false);
    this.token=session.access_token;this.expires=Date.now()+(session.expires_in-30)*1000;
  }
  async presence(){await this.http('/directory',{name:this.identity.name,alias:this.identity.alias,page_id:this.pageId,discoverable:this.discoverable});this.lastPresence=Date.now();}
  async discovery(value){
    this.discoverable=!!value;if(value)this.autoPauseArmed=false;this.onChange();
    try{await this.presence();}finally{this.onChange();}
  }
  async search(query){this.autoPauseArmed=false;if(!this.discoverable)await this.discovery(true);return this.http('/search',{query});}
  contacts(){const map=new Map();for(const r of this.rooms)for(const m of r.members)if(m.id!==this.identity.id)map.set(m.id,m);return [...map.values()];}
  async propose(members,title){
    this.autoPauseArmed=false;await this.discovery(true);
    const own={id:this.identity.id,name:this.identity.name,public_key:this.identity.public_key};
    const unique=[own,...members.filter(m=>m.id!==own.id).map(m=>({id:m.id,name:m.name,public_key:m.public_key}))];
    const payload=JSON.stringify({version:1,nonce:crypto.randomUUID(),owner:own.id,title:title||unique.map(m=>m.name).join('、').slice(0,40),members:unique});
    const signature=await sign(this.identity,'zhuge-im-room-v1\n'+payload);
    await validateRoom({payload,signatures:{[own.id]:signature}},own.id,false);
    return this.http('/rooms/propose',{payload,signature});
  }
  async respond(id,accept){
    const invite=this.invitations.find(i=>i.id===id);if(!invite)throw new Error('邀请已结束。');
    if(accept){const room=await validateRoom(invite,this.identity.id,false);if(room.members.some(m=>this.identity.blocked.includes(m.id)))throw new Error('邀请中包含已屏蔽的设备。');}
    await this.http('/rooms/respond',{room_id:id,accept,signature:accept?await sign(this.identity,'zhuge-im-room-v1\n'+invite.payload):''});
  }
  async block(id){
    if(id===this.identity.id)throw new Error('不能屏蔽自己。');
    if(!this.identity.blocked.includes(id))this.identity.blocked.push(id);
    this.identity.rooms=this.identity.rooms.filter(e=>!JSON.parse(e.payload).members.some(m=>m.id===id));
    await saveDevice(this.identity);await this.loadRooms();this.onChange();
  }
  async request(path,body={},method='POST'){
    if(path==='/identity')return {id:this.identity.id,enterprise_id:0};
    if(path==='/poll'){
      this.pageId=body.page_id;
      let signals=[];
      if(this.discoverable){
        if(Date.now()-this.lastPresence>25000)await this.presence();
        const peers=[...new Set(this.rooms.flatMap(r=>r.members.map(m=>m.id)))].filter(id=>id!==this.identity.id);
        const result=await this.http('/poll',{page_id:this.pageId,peers});this.links=result.peers;
        const invitations=[];let changed=false;
        for(const row of result.invites){
          try{
            const r=await validateRoom(row,this.identity.id,false);if(r.digest!==row.id||r.members.some(m=>this.identity.blocked.includes(m.id)))continue;
            const complete=!row.declined&&r.members.every(m=>!!row.signatures[String(m.id)]);
            if(complete&&!this.rooms.some(room=>room.digest===r.digest)){
              const approved=await validateRoom(row,this.identity.id);
              if(approved.members.some(m=>this.identity.blocked.includes(m.id)))continue;
              if(this.rooms.some(room=>room.id===approved.id))throw new Error('会话编号冲突，请重新邀请。');
              this.rooms.push(approved);this.autoPauseArmed=true;this.identity.rooms.push({payload:row.payload,signatures:row.signatures});changed=true;
            }
            if(!this.rooms.some(room=>room.digest===r.digest))invitations.push({...row,room:r,complete});
          }catch(e){this.onNotice(e.message);}
        }
        this.invitations=invitations;if(changed)await saveDevice(this.identity);
        const ignored=[];
        for(const row of result.signals.reverse()){
          try{
            const d=JSON.parse(row.payload),room=this.rooms.find(r=>r.digest===d.room),member=room?.members.find(m=>m.id===d.from);
            if(!member||d.to!==this.identity.id||d.peer_page_id!==this.pageId||d.expires<Date.now()/1000||d.expires>Date.now()/1000+185||!await verify(member.public_key,'zhuge-im-signal-v1\n'+row.payload,row.signature))throw new Error();
            const link=this.links.find(l=>l.peer_user_id===d.from);if(!link||link.peer_page_id!==d.page_id)throw new Error();
            signals.push({id:row.id,peer_user_id:d.from,channel_id:d.channel_id,signal_type:d.signal_type,signal:d.signal});
          }catch{ignored.push(row.id);}
        }
        if(ignored.length)await this.http('/signals/ack',{page_id:this.pageId,ids:ignored});
      }
      const wanted=new Set(this.rooms.flatMap(r=>r.members.map(m=>m.id)));
      const peers=this.links.filter(l=>wanted.has(l.peer_user_id)).map(l=>this.discoverable?l:{...l,online:false});
      return {user:{id:this.identity.id,enterprise_id:0,display_name:this.identity.name},conversations:this.conversations(),peers,signals,ice_servers:[{urls:'stun:zhugejunshi.com:3478'}],transport:'direct_only'};
    }
    if(path==='/signals'){
      if(!this.discoverable)return {ignored:true};
      const room=this.rooms.find(r=>r.members.some(m=>m.id===body.peer_user_id));if(!room)throw new Error('该设备尚未确认连接。');
      const payload=JSON.stringify({room:room.digest,from:this.identity.id,to:body.peer_user_id,page_id:body.page_id,peer_page_id:body.peer_page_id,channel_id:body.channel_id,signal_type:body.signal_type,signal:body.signal,expires:Math.floor(Date.now()/1000)+120,nonce:crypto.randomUUID()});
      return this.http('/signals',{envelope:{payload:room.envelope.payload,signatures:room.envelope.signatures},payload,signature:await sign(this.identity,'zhuge-im-signal-v1\n'+payload)});
    }
    if(path==='/signals/ack')return this.http('/signals/ack',body);
    throw new Error('此入口不属于设备直连功能。');
  }
  async backup(chat,password){const {privateKey,...identity}=this.identity;return seal({identity:{...identity,privateJwk:await crypto.subtle.exportKey('jwk',privateKey)},chat:await chat.text()},password);}
  close(){this.closed=true;this.token='';this.expires=0;}
}

export async function restoreGuestIdentity(file,password){
  const data=await unseal(file,password),value=data.identity;
  if(!value||value.id!==await numberFor(value.public_key)||!Array.isArray(value.rooms)||!Array.isArray(value.blocked)||typeof data.chat!=='string')throw new Error('设备备份不完整。');
  const privateKey=await crypto.subtle.importKey('jwk',value.privateJwk,{name:'ECDSA',namedCurve:'P-256'},true,['sign']);
  const probe=await sign({privateKey},'device-restore');if(!await verify(value.public_key,'device-restore',probe))throw new Error('设备密钥不匹配。');
  for(const room of value.rooms)await validateRoom(room,value.id);
  const current=await readDevice();if(current&&current.id!==value.id)throw new Error('当前浏览器已有另一台设备身份。请使用独立浏览器配置恢复，原身份和记录会保留。');
  const {privateJwk,...rest}=value;return {identity:{...rest,privateKey},chat:new File([data.chat],'聊天备份.json',{type:'application/json'})};
}
",
      "guest-identity.js": "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",
      "integrity.js": "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",
      "recovery.html": "PCFkb2N0eXBlIGh0bWw+PGh0bWwgbGFuZz0iemgtQ04iPjxoZWFkPjxtZXRhIGNoYXJzZXQ9InV0Zi04Ij48bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ZGV2aWNlLXdpZHRoLGluaXRpYWwtc2NhbGU9MSI+PHRpdGxlPuajgOafpeS4juaBouWkjTwvdGl0bGU+PHN0eWxlPmJvZHl7bWF4LXdpZHRoOjg1MHB4O21hcmdpbjozMHB4IGF1dG87cGFkZGluZzowIDE4cHg7Y29sb3I6IzIwMjEyNDtmb250OjE0cHgvMS43ICJNaWNyb3NvZnQgWWFIZWkiLEFyaWFsLHNhbnMtc2VyaWZ9aDF7Zm9udC1zaXplOjIycHh9YnV0dG9uLGEsaW5wdXR7Zm9udDppbmhlcml0O2ZvbnQtd2VpZ2h0OjQwMDtjb2xvcjojMjU2M2VifWJ1dHRvbntwYWRkaW5nOjEwcHggMTRweDttYXJnaW46NnB4O2JhY2tncm91bmQ6d2hpdGU7Ym9yZGVyOjFweCBzb2xpZCAjZTRlNmViO2N1cnNvcjpwb2ludGVyfWJ1dHRvbjpkaXNhYmxlZHtvcGFjaXR5Oi41fXByZXt3aGl0ZS1zcGFjZTpwcmUtd3JhcDtvdmVyZmxvdy13cmFwOmFueXdoZXJlfWE6Zm9jdXMtdmlzaWJsZSxidXR0b246Zm9jdXMtdmlzaWJsZXtvdXRsaW5lOjJweCBzb2xpZCAjMjU2M2VifTwvc3R5bGU+PC9oZWFkPjxib2R5PjxhIGhyZWY9Ii8iPui/lOWbnuiBiuWkqTwvYT48aDE+5qOA5p+l5LiO5oGi5aSNPC9oMT48cD7mgaLlpI3liY3kv53lrZjkuIDku73njrDmnInmoLjlv4Pmlofku7bjgILmgqjnmoTnlYzpnaLjgIHmianlsZXlkozmtY/op4jlmajogYrlpKnorrDlvZXkvJrkv53nlZnjgILmk43kvZzlrozmiJDlkI7or7fph43mlrDlkK/liqjnqIvluo/jgII8L3A+PHAgaWQ9InN0YXR1cyIgcm9sZT0ic3RhdHVzIj7mraPlnKjmo4Dmn6XigKY8L3A+PHByZSBpZD0iZGV0YWlscyI+PC9wcmU+PGJ1dHRvbiBpZD0icmVzdG9yZSI+5oGi5aSN5pys54mI5pys5qC45b+DPC9idXR0b24+PGxhYmVsPumAieaLqeWumOaWueWNh+e6p+aWh+S7tiA8aW5wdXQgaWQ9InVwZGF0ZSIgdHlwZT0iZmlsZSIgYWNjZXB0PSIuanNvbiI+PC9sYWJlbD48cD7or7fku47pgJrkv6Hog73lipvnmoTniYjmnKzpobXpnaLkuIvovb3ljYfnuqfmlofku7bjgILljYfnuqfkvJrmo4Dmn6Xnrb7lkI3jgIHljY/orq7lj4rmnKzlnLDorrDlvZXmoLzlvI/jgII8L3A+PGEgaHJlZj0iaHR0cHM6Ly96aHVnZWp1bnNoaS5jb20vY2FwYWJpbGl0eS1tYXJrZXQvZGlyZWN0LWltL3ZlcnNpb25zIiB0YXJnZXQ9Il9ibGFuayIgcmVsPSJub29wZW5lciI+5p+l55yL5a6Y5pa554mI5pysPC9hPjxzY3JpcHQgdHlwZT0ibW9kdWxlIiBzcmM9Ii4vcmVjb3ZlcnkuanMiPjwvc2NyaXB0PjwvYm9keT48L2h0bWw+Cg==",
      "recovery.js": "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",
      "release-key.json": "ewogICJrdHkiOiAiUlNBIiwKICAibiI6ICJ4cUQ1RXItOXoxVm5TeV8zNW9ZMjIwVlZVSWFMVGR5bFZYTDZaSl9lOTJ4cDBTakJCTEhLdUlmVkxOaFZnQk92NTM5VXVrekdMa3hMZktiZmFXdm0wSVh6ZkluWW5oeVd2LXFrTjNQbjQ5ZXk0Ml9oaUhpRG5MR1h1WERfRmpiNnNNNmZSV3ZQbmVaNUhnZ1gtZ2RhNEhMcmJGakpzOVBLaE5hZjVjNk1RM3RTeTQ4bEZSZFJHOXk0a3U0a2VHVDhQM1VLMURDcUFxdWhiSWQtQlZqWmF2MndraDV4WnRFOXhKaElxaGV6cExZa0otb2JXRDdqNFhkdk5QMTVfblJ1anhsY3RNNk5rM3ZHdkhlS3Vla0JLRjA5ZXZMVktrOWVULXNMaUotUlI1NFRKZDFpdllIaFNWbGN6bldFTUtSRThzVWw5TFlveEhETWdwMm1JWVc3OGx6OFVodmpFbW1ibUN3dFZGLU5yYmpOYjJ4RDlCWHhQcVlMY3ptOVhMWElGRzFHNGUxNVFwUzVndy1WWnA5dDhyQ2Nnbi1mV0k4ZXRqSEhaaFQ4UzM0S3FDREc5c2NZUlYtdXhER21ja2hrbG1pa0MwLVdBYzE3djU0OGJHZm5GbHVYN0pDRkhfZG52R2JrOHNoT3lMZ2EwdWdXNUdJRXBpYWpFdk9HbndsTCIsCiAgImUiOiAiQVFBQiIKfQ==",
      "sdk.js": "import {DirectChatClient} from './src/client.js';
import {platformOrigin} from './config.js';
import {checkCore} from './integrity.js';
import {GuestControl,restoreGuestIdentity} from './guest-control.js';
import {readDevice,saveDevice} from './guest-identity.js';
import {LocalChatStore} from './src/storage.js';

// Do not expose the raw client, credentials, storage handle or transport to extensions.
export function createChatApp({onChange=()=>{},onNotice=()=>{}}={}) {
  let client, guest, token='', pending, popup, state='', checkTimer, checking=false, generation=0;
  const requireClient=()=>{if(!client?.snapshot)throw new Error('请先连接账号。');return client;};
  const disconnect=()=>{generation++;clearInterval(checkTimer);client?.stop();guest?.close();client=undefined;guest=undefined;token='';state='';if(pending){clearTimeout(pending.timer);pending.reject(new Error('连接已取消。'));pending=undefined;}onChange();};
  const watch=async()=>{if(checking)return;checking=true;try{await checkCore();}catch(e){disconnect();onNotice(e.message);}finally{checking=false;}};
  const listener=async event=>{
    if(!pending||!state||event.origin!==new URL(platformOrigin).origin||event.source!==popup||event.data?.type!=='zhuge-direct-im-session'||event.data?.state!==state)return;
    const active=pending;pending=undefined;clearTimeout(active.timer);state='';const epoch=generation;
    try{
      await checkCore();if(epoch!==generation)throw new Error('连接已取消。');
      token=String(event.data.access_token||'');if(!token.startsWith('imdc_'))throw new Error('请使用通信专用连接授权。');
      client=new DirectChatClient({baseUrl:`${platformOrigin}/api/im-direct`,token:()=>token,onChange,onNotice});
      await client.start();if(epoch!==generation)throw new Error('连接已取消。');
      checkTimer=setInterval(()=>void watch(),10000);active.resolve();
    }catch(e){disconnect();active.reject(e);}
  };
  window.addEventListener('message',listener);
  window.addEventListener('pagehide',disconnect);
  return Object.freeze({
    apiVersion:1,
    async savedDevice(){const device=await readDevice();return device?{id:device.id,name:device.name,alias:device.alias}:null;},
    get device(){return guest?structuredClone(guest.profile()):undefined;},
    get invitations(){return guest?structuredClone(guest.invitations):[];},
    get deviceContacts(){return guest?structuredClone(guest.contacts()):[];},
    async connectDevice(name,alias=''){
      disconnect();const epoch=generation;await checkCore();
      const control=await GuestControl.create(name,alias,onChange,onNotice);
      if(epoch!==generation){control.close();throw new Error('连接已取消。');}
      guest=control;client=new DirectChatClient({baseUrl:'',token:()=>'',deviceControl:control,onChange,onNotice});
      try{await client.start();if(epoch!==generation)throw new Error('连接已取消。');checkTimer=setInterval(()=>void watch(),10000);}catch(e){disconnect();throw e;}
    },
    async searchDevices(query){await checkCore();if(!guest)throw new Error('请先打开自己的设备。');return guest.search(query);},
    async inviteDevices(members,title){await checkCore();if(!guest)throw new Error('请先打开自己的设备。');const r=await guest.propose(members,title);await client.poll();return r;},
    async answerInvitation(id,accept){await checkCore();if(!guest)throw new Error('请先打开自己的设备。');await guest.respond(id,accept);await client.poll();},
    async discoverDevices(value){if(!guest)throw new Error('请先打开自己的设备。');await guest.discovery(value);await client.poll();},
    async blockDevice(id){if(!guest)throw new Error('请先打开自己的设备。');await guest.block(id);await client.poll();},
    async restoreDevice(file,password){
      await checkCore();if(client)throw new Error('请先断开当前连接再恢复。');
      const data=await restoreGuestIdentity(file,password),store=new LocalChatStore(data.identity.id);
      try{await store.open();await store.restore(data.chat,password);await saveDevice(data.identity);}finally{store.close();}
      return {id:data.identity.id,name:data.identity.name,alias:data.identity.alias};
    },
    get connectionRevision(){return generation;},
    get snapshot(){return client?.snapshot?structuredClone({user:client.snapshot.user,conversations:client.snapshot.conversations}):undefined;},
    check:checkCore,
    connect(){
      disconnect();state=crypto.randomUUID();const url=new URL('/im/connect',platformOrigin);url.searchParams.set('origin',location.origin);url.searchParams.set('state',state);
      popup=window.open(url,'zhuge-direct-im-connect','width=640,height=720');
      if(!popup){state='';return Promise.reject(new Error('请允许打开账号连接窗口。'));}
      return new Promise((resolve,reject)=>{pending={resolve,reject,timer:setTimeout(()=>{state='';pending=undefined;reject(new Error('连接等待超时，请重新连接。'));},90000)};});
    },
    disconnect,
    dispose(){disconnect();window.removeEventListener('message',listener);window.removeEventListener('pagehide',disconnect);},
    status:id=>client?.status(id)||'尚未连接',
    messages:id=>requireClient().messages(id),
    async sendText(id,text){await checkCore();return requireClient().send(id,text);},
    async sendFile(id,file){await checkCore();return requireClient().send(id,`文件：${file.name}`,'file',{},file);},
    markRead:id=>requireClient().store.markRead(id),
    friends:()=>requireClient().api('/metadata',{path:'/im/friends',method:'GET'}),
    async openConversation(peer){const c=requireClient();const result=await c.api('/metadata',{path:'/im/conversations/direct',method:'POST',body:{current_user_id:c.snapshot.user.id,peer_user_id:peer}});await c.poll();return result;},
    async backup(password){const chat=await requireClient().store.backup(password);return guest?guest.backup(chat,password):chat;},
    restore:(file,password)=>requireClient().store.restore(file,password),
  });
}
",
      "server.mjs": "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",
      "src/client.ts": "import { LocalChatStore, ChatRecord, toBase64, fromBase64 } from "./storage";

export type Conversation = { id: number; title: string; conversation_type?: string; participants: { user_id: number; display_name: string }[]; [key: string]: unknown };
type Link = { peer_user_id: number; peer_page_id: string | null; online: boolean };
type Signal = { id: number|string; peer_user_id: number; channel_id: string; signal_type: "offer"|"answer"|"ice"; signal: RTCSessionDescriptionInit & RTCIceCandidateInit };
export type Snapshot = { user: {id: number; enterprise_id: number; display_name: string}; conversations: Conversation[]; peers: Link[]; signals: Signal[]; ice_servers: RTCIceServer[]; transport: string };
type Wire = { type: "message"; version: 1; id: string; conversation_id: number; sender_user_id: number; content: string; message_type: string; created_at: string; metadata_json: Record<string, unknown> };
type Peer = { link: Link; pc: RTCPeerConnection; channel?: RTCDataChannel; channelId: string; pending: RTCIceCandidateInit[]; ready: boolean; queue: Promise<void>; pumping: boolean; seen: Set<number|string>; started: number; signalQueue: Promise<void> };
type Transfer = { message: Wire; parts: Uint8Array<ArrayBuffer>[]; received: number; chunks: number; touched: number };
const MAX_FILE = 25*1024*1024;
const CHUNK = 12*1024;
const UUID = /^[a-f0-9-]{36}$/i;
export type DeviceControl = {
  request(path: string, body?: unknown, method?: string): Promise<unknown>;
  trusted(peer: number, conversation: number): boolean;
  connected(peers: number[]): void;
  close(): void;
};
export type DirectOptions = { baseUrl: string; token: () => string; onChange?: () => void; onNotice?: (text: string) => void; deviceControl?: DeviceControl };

export class DirectChatClient {
  readonly pageId = crypto.randomUUID();
  store?: LocalChatStore;
  snapshot?: Snapshot;
  private peers = new Map<number, Peer>();
  private inbound = new Map<string, Transfer>();
  private timer?: ReturnType<typeof setTimeout>;
  private alive = false;
  private polling = false;
  private authenticatedAt = 0;
  private nextSend = new Map<string, number>();
  private released?: () => void;
  constructor(readonly options: DirectOptions) {}
  async api<T>(path: string, body?: unknown, method = "POST"): Promise<T> {
    if (!this.alive) throw new Error("连接已结束，请重新打开聊天。");
    if (this.options.deviceControl) return this.options.deviceControl.request(path, body, method) as Promise<T>;
    const token = this.options.token();
    if (!token) throw new Error("请先连接自己的账号。");
    const response = await fetch(`${this.options.baseUrl.replace(/\/$/, "")}${path}`, {
      method, credentials: "omit", cache: "no-store", signal: AbortSignal.timeout(12000),
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    if (!response.ok) {
      if (response.status === 401 || response.status === 403) this.disconnectPeers();
      const data = await response.json().catch(() => ({}));
      if (data.detail?.code === "device_replaced") { this.stop(); throw new Error(data.detail.message); }
      throw new Error(typeof data.detail === "string" ? data.detail : `连接暂时未完成（${response.status}）。`);
    }
    return response.json();
  }
  async start() {
    if (this.alive) return;
    this.alive = true;
    try {
      const identity = await this.api<{id:number}>("/identity", undefined, "GET");
      if (!this.alive) return;
      // One tab per account/origin owns a device node; other tabs never fight over signaling.
      if (navigator.locks) await new Promise<void>((resolve,reject) => {
        void navigator.locks.request(`zhuge-direct-im-${identity.id}`, { ifAvailable: true }, async lock => {
          if (!lock) { reject(new Error("此账号已在另一个窗口打开聊天，请先关闭那个窗口。")); return; }
          resolve(); await new Promise<void>(release => { this.released = release; });
        });
      });
      this.store = new LocalChatStore(identity.id); await this.store.open();
      if (!this.alive) { this.store.close(); this.released?.(); return; }
      const first = await this.api<Snapshot>("/poll", { page_id: this.pageId, activate: true });
      this.snapshot = first; this.authenticatedAt = Date.now(); this.options.onChange?.();
      void navigator.storage?.persist?.().catch(() => false);
      await this.applySnapshot(first);
      this.schedule();
    } catch (error) { this.stop(); throw error; }
  }
  private schedule() { clearTimeout(this.timer); if (this.alive) this.timer = setTimeout(() => void this.poll(), 2500); }
  async poll() {
    if (!this.alive || this.polling) return;
    this.polling = true;
    try {
      const data = await this.api<Snapshot>("/poll", { page_id: this.pageId });
      if (!this.alive) return;
      if (this.store?.account !== data.user.id) { this.stop(); throw new Error("账号已改变，请重新打开聊天。"); }
      this.authenticatedAt = Date.now(); this.snapshot = data;
      await this.applySnapshot(data); this.options.onChange?.();
      for (const [key, value] of Array.from(this.inbound)) if (Date.now()-value.touched > 60000) this.inbound.delete(key);
    } catch (error) { this.notice(error); } finally { this.polling = false; this.schedule(); }
  }
  private notice(error: unknown) { this.options.onNotice?.(error instanceof Error ? error.message : "连接暂时不可用。"); }
  private allowed(peer: number, conversation: number) {
    const c = this.snapshot?.conversations.find(c => c.id === conversation);
    const valid = this.options.deviceControl ? this.options.deviceControl.trusted(peer, conversation) : Date.now()-this.authenticatedAt < 120000;
    return valid && !!c?.participants.some(p => p.user_id === peer) && !!c.participants.some(p => p.user_id === this.store?.account);
  }
  private async applySnapshot(data: Snapshot) {
    if (data.transport !== "direct_only") throw new Error("当前连接方式不符合设备直连要求。");
    const reachable = new Set(data.peers.map(l => l.peer_user_id));
    for (const [uid, peer] of Array.from(this.peers)) if (!reachable.has(uid)) this.closePeer(uid, peer);
    for (const link of data.peers) {
      let peer = this.peers.get(link.peer_user_id);
      if (peer && link.online && peer.link.peer_page_id !== link.peer_page_id) { this.closePeer(link.peer_user_id, peer); peer = undefined; }
      if (peer && !peer.ready && Date.now()-peer.started > 25000) { this.closePeer(link.peer_user_id, peer); peer = undefined; }
      // A failed presence request must not tear down an established direct connection.
      if (!peer && link.online) {
        peer = this.createPeer(link);
        if (data.user.id < link.peer_user_id) {
          this.configureChannel(peer, peer.pc.createDataChannel("zhuge-im-v1", { ordered: true }));
          const offer = await peer.pc.createOffer(); await peer.pc.setLocalDescription(offer);
          await this.sendSignal(peer, "offer", { type: "offer", sdp: offer.sdp });
        }
      }
    }
    const ack: (number|string)[] = [];
    for (const signal of data.signals) {
      const peer = this.peers.get(signal.peer_user_id);
      if (!peer) continue;
      if (!peer.seen.has(signal.id)) {
        try { await this.acceptSignal(peer, signal); peer.seen.add(signal.id); }
        catch { continue; }
      }
      ack.push(signal.id);
    }
    if (ack.length) await this.api("/signals/ack", {page_id: this.pageId, ids: ack});
    for (const peer of Array.from(this.peers.values())) if (peer.ready) void this.pump(peer);
    this.options.deviceControl?.connected(Array.from(this.peers).filter(([,p])=>p.ready).map(([uid])=>uid));
  }
  private createPeer(link: Link): Peer {
    const ice = (this.snapshot?.ice_servers || []).map(s => ({ urls: (Array.isArray(s.urls) ? s.urls : [s.urls]).filter(u => u.startsWith("stun:")) })).filter(s => s.urls.length);
    const pc = new RTCPeerConnection({ iceServers: ice });
    const peer: Peer = { link, pc, channelId: crypto.randomUUID(), pending: [], ready: false, queue: Promise.resolve(), pumping: false, seen: new Set(), started: Date.now(), signalQueue: Promise.resolve() };
    this.peers.set(link.peer_user_id, peer);
    pc.onicecandidate = e => { if (e.candidate) { const c = e.candidate.toJSON(); void this.sendSignal(peer, "ice", { candidate: c.candidate, sdpMid: c.sdpMid, sdpMLineIndex: c.sdpMLineIndex }).catch(error => this.notice(error)); } };
    pc.ondatachannel = e => this.configureChannel(peer, e.channel);
    pc.onconnectionstatechange = () => { if (["failed", "closed"].includes(pc.connectionState)) { peer.ready = false; this.options.onChange?.(); } };
    return peer;
  }
  private async sendSignal(peer: Peer, type: string, signal: unknown) {
    if (!this.alive) return;
    const send = () => this.api("/signals", { page_id: this.pageId, peer_user_id: peer.link.peer_user_id,
      peer_page_id: peer.link.peer_page_id, channel_id: peer.channelId, signal_type: type, signal }).then(() => undefined);
    peer.signalQueue = peer.signalQueue.then(send); return peer.signalQueue;
  }
  private async acceptSignal(peer: Peer, signal: Signal) {
    if (signal.signal_type === "offer") {
      if (this.store!.account < peer.link.peer_user_id) return;
      if (peer.pc.signalingState !== "stable" || peer.pc.remoteDescription) return;
      peer.channelId = signal.channel_id;
      await peer.pc.setRemoteDescription(signal.signal);
      for (const c of peer.pending.splice(0)) await peer.pc.addIceCandidate(c);
      const answer = await peer.pc.createAnswer(); await peer.pc.setLocalDescription(answer);
      await this.sendSignal(peer, "answer", {type: "answer", sdp: answer.sdp});
    } else if (signal.signal_type === "answer") {
      if (signal.channel_id !== peer.channelId || peer.pc.signalingState !== "have-local-offer") return;
      await peer.pc.setRemoteDescription(signal.signal);
      for (const c of peer.pending.splice(0)) await peer.pc.addIceCandidate(c);
    } else {
      if (this.store!.account < peer.link.peer_user_id && signal.channel_id !== peer.channelId) return;
      if (peer.pc.remoteDescription) await peer.pc.addIceCandidate(signal.signal);
      else peer.pending.push(signal.signal);
    }
  }
  private configureChannel(peer: Peer, channel: RTCDataChannel) {
    if (channel.label !== "zhuge-im-v1" || peer.channel) { channel.close(); return; }
    peer.channel = channel;
    channel.onopen = async () => {
      const stats = await peer.pc.getStats(); let relay = false;
      stats.forEach(s => { if ((s.type === "local-candidate" || s.type === "remote-candidate") && s.candidateType === "relay") relay = true; });
      if (relay) { this.closePeer(peer.link.peer_user_id, peer); this.notice(new Error("已停止中继连接，请使用可直连网络。")); return; }
      peer.ready = true; this.options.onChange?.(); void this.pump(peer);
    };
    channel.onclose = channel.onerror = () => { peer.ready = false; this.options.onChange?.(); };
    channel.onmessage = event => {
      if (typeof event.data !== "string" || event.data.length > 24000) return;
      // Preserve wire order across asynchronous IndexedDB/hash operations.
      peer.queue = peer.queue.then(() => this.receive(peer, JSON.parse(event.data))).catch(error => this.notice(error));
    };
  }
  private async write(peer: Peer, value: unknown) {
    const channel = peer.channel;
    if (!this.alive || !channel || channel.readyState !== "open") throw new Error("对方暂时离线，消息会留在本机等待重连。");
    const started = Date.now();
    while (channel.bufferedAmount > 256*1024) {
      if (Date.now()-started > 15000 || channel.readyState !== "open" || !this.alive) throw new Error("文件传输中断，正在等待重连。");
      await new Promise(resolve => setTimeout(resolve, 25));
    }
    channel.send(JSON.stringify(value));
  }
  private async pump(peer: Peer) {
    if (peer.pumping || !this.store) return;
    peer.pumping = true;
    try {
      const records = await this.store.list();
      for (const r of records) {
        const key = `${r.direct_id}:${peer.link.peer_user_id}`;
        if (!r.is_mine || !r.recipient_ids.includes(peer.link.peer_user_id) || r.delivered_to.includes(peer.link.peer_user_id) || !this.allowed(peer.link.peer_user_id,r.conversation_id) || (this.nextSend.get(key)||0)>Date.now()) continue;
        this.nextSend.set(key, Date.now()+30000);
        const wire: Wire = {type:"message", version:1, id:r.direct_id, conversation_id:r.conversation_id,
          sender_user_id:r.sender_user_id, content:r.content, message_type:r.message_type, created_at:r.created_at, metadata_json:r.metadata_json};
        await this.write(peer, wire);
        if (r.message_type === "file") {
          const file = await this.store.file(r.direct_id);
          if (!file) throw new Error("待发文件已不在本机，请重新选择文件。");
          const data = new Uint8Array(file);
          for (let start=0;start<data.length;start+=CHUNK) await this.write(peer, {type:"chunk", id:r.direct_id, index:start/CHUNK, data:toBase64(data.subarray(start,start+CHUNK))});
        }
      }
    } catch (error) { this.notice(error); } finally { peer.pumping = false; }
  }
  private validMessage(value: Wire, peer: Peer): boolean {
    if (value.version!==1 || !UUID.test(value.id) || value.sender_user_id!==peer.link.peer_user_id || !this.allowed(peer.link.peer_user_id,value.conversation_id)) return false;
    if (typeof value.content!=="string" || value.content.length>4000 || typeof value.created_at!=="string" || value.created_at.length>40 || !["text","file","location","call"].includes(value.message_type)) return false;
    if (!value.metadata_json || typeof value.metadata_json!=="object" || JSON.stringify(value.metadata_json).length>2000) return false;
    return true;
  }
  private async receive(peer: Peer, value: Wire & {data?: string; index?: number}) {
    if (!this.store || !this.alive) return;
    const kind: string = value.type;
    if (kind === "ack") {
      await this.store.exclusive(async () => {
        const r = await this.store!.find(value.id);
        if (!r?.is_mine || !r.recipient_ids.includes(peer.link.peer_user_id) || r.delivered_to.includes(peer.link.peer_user_id)) return;
        r.delivered_to.push(peer.link.peer_user_id); r.local_status = r.recipient_ids.every(id=>r.delivered_to.includes(id)) ? "sent":"sending";
        await this.store!.save(r);
      }); this.options.onChange?.(); return;
    }
    if (kind === "message") {
      if (!this.validMessage(value,peer)) return;
      const existing = await this.store.find(value.id);
      if (existing) { if (existing.sender_user_id === value.sender_user_id && existing.conversation_id === value.conversation_id && existing.content === value.content) await this.write(peer,{type:"ack",id:value.id}); return; }
      if (value.message_type === "file") {
        const a = value.metadata_json.attachment as {size:number;original_name:string;sha256:string;content_type:string};
        if (!a || !Number.isSafeInteger(a.size) || a.size<1 || a.size>MAX_FILE || typeof a.original_name!=="string" || a.original_name.length>240 || !/^[a-f0-9]{64}$/.test(a.sha256)) return;
        if (this.inbound.size>=4 && !this.inbound.has(value.id)) return;
        this.inbound.set(value.id,{message:value,parts:[],received:0,chunks:0,touched:Date.now()}); return;
      }
      await this.acceptMessage(peer,value); return;
    }
    if (kind === "chunk") {
      const transfer = this.inbound.get(value.id);
      if (!transfer || transfer.message.sender_user_id!==peer.link.peer_user_id || !this.allowed(peer.link.peer_user_id,transfer.message.conversation_id) || value.index!==transfer.chunks || typeof value.data!=="string" || value.data.length>CHUNK*4/3) return;
      const chunk = fromBase64(value.data); const a = transfer.message.metadata_json.attachment as {size:number;sha256:string};
      if (!chunk.length || transfer.received+chunk.length>a.size) { this.inbound.delete(value.id); return; }
      transfer.parts.push(chunk); transfer.received+=chunk.length; transfer.chunks++; transfer.touched=Date.now();
      if (transfer.received===a.size) {
        const file = new Blob(transfer.parts);
        if (await hash(await file.arrayBuffer())!==a.sha256) {this.inbound.delete(value.id); throw new Error("文件校验失败，未保存文件。");}
        await this.store.saveFile(value.id,file);
        await this.acceptMessage(peer,transfer.message); this.inbound.delete(value.id);
      }
    }
  }
  private async acceptMessage(peer: Peer, wire: Wire) {
    await this.store!.exclusive(async () => {
      if (await this.store!.find(wire.id)) return;
      const members = this.snapshot!.conversations.find(c=>c.id===wire.conversation_id)!.participants;
      // Never trust a remote attachment URL or label for the sender identity.
      const metadata: Record<string, unknown> = {};
      if (wire.message_type==="file") { const a = wire.metadata_json.attachment as Record<string,unknown>; metadata.attachment = {original_name:String(a.original_name),size:Number(a.size),content_type:"application/octet-stream",sha256:String(a.sha256)}; }
      if (wire.message_type==="location") { const p=wire.metadata_json.location as Record<string,unknown>; if (p && typeof p.latitude==="number" && Math.abs(p.latitude)<=90 && typeof p.longitude==="number" && Math.abs(p.longitude)<=180) metadata.location={latitude:p.latitude,longitude:p.longitude}; }
      await this.store!.save({id:await this.store!.nextId(),direct_id:wire.id,conversation_id:wire.conversation_id,sender_user_id:wire.sender_user_id,
        sender_name:members.find(p=>p.user_id===wire.sender_user_id)?.display_name || "联系人",content:wire.content,message_type:wire.message_type,created_at:wire.created_at,
        metadata_json:metadata,recipient_ids:[],delivered_to:[],is_mine:false,local_status:"sent"});
    });
    this.options.onChange?.(); await this.write(peer,{type:"ack",id:wire.id});
  }
  async send(conversation: number, content: string, messageType="text", metadata: Record<string,unknown>={}, file?: File): Promise<ChatRecord> {
    if (!this.alive || !this.store || !this.snapshot) throw new Error("连接已结束，请重新打开聊天。");
    const c = this.snapshot.conversations.find(c=>c.id===conversation);
    if (!c || content.length>4000 || !content.trim()) throw new Error("请选择会话，消息不能超过 4000 个字。");
    const recipients = c.participants.map(p=>p.user_id).filter(id=>id!==this.store!.account);
    if (!recipients.length || recipients.some(peer=>!this.allowed(peer,conversation))) throw new Error("请重新连接并确认会话成员后发送。");
    const id=crypto.randomUUID();
    if (file) {
      if (!file.size || file.size>MAX_FILE) throw new Error("文件大小需在 1 字节至 25 MB 之间。");
      metadata={attachment:{original_name:file.name.slice(0,240),size:file.size,content_type:file.type||"application/octet-stream",sha256:await hash(await file.arrayBuffer())}};
      await this.store.saveFile(id,file);
    }
    const record=await this.store.exclusive(async () => {
      const r:ChatRecord={id:await this.store!.nextId(),direct_id:id,conversation_id:conversation,sender_user_id:this.store!.account,
        sender_name:this.snapshot!.user.display_name,content,message_type:messageType,created_at:new Date().toISOString(),metadata_json:metadata,
        recipient_ids:recipients,delivered_to:[],is_mine:true,local_status:"sending"};
      await this.store!.save(r);return r;
    });
    this.options.onChange?.(); for (const peer of Array.from(this.peers.values())) if (peer.ready) void this.pump(peer); return record;
  }
  async messages(conversation: number): Promise<ChatRecord[]> {
    if (!this.store) return [];
    const rows=await this.store.list(conversation);
    return Promise.all(rows.map(async r=>{
      if (r.message_type!=="file") return r;
      const a=r.metadata_json.attachment as Record<string,unknown>;
      const url=await this.store!.fileUrl(r.direct_id,String(a.content_type||"application/octet-stream"));
      return {...r,metadata_json:{...r.metadata_json,attachment:{...a,url}}};
    }));
  }
  async conversationViews<T extends Conversation>(items: T[]): Promise<T[]> {
    if (!this.store) return items;
    const messages=await this.store.list();
    return Promise.all(items.map(async c=>{ const rows=messages.filter(r=>r.conversation_id===c.id);const read=await this.store!.readAt(c.id);const last=rows.at(-1);
      return {...c,last_message:last||null,last_message_at:last?.created_at||null,unread_count:rows.filter(r=>!r.is_mine && r.id>read).length}; }));
  }
  status(conversation: number) {
    const ids=this.snapshot?.conversations.find(c=>c.id===conversation)?.participants.filter(p=>p.user_id!==this.store?.account).map(p=>p.user_id)||[];
    const online=ids.filter(id=>this.peers.get(id)?.ready).length;
    return online===ids.length && online>0 ? "设备已直连" : online>0 ? `${online}/${ids.length} 位成员已直连` : "等待对方上线或网络直连";
  }
  private closePeer(uid:number,peer:Peer) { peer.channel?.close();peer.pc.close();this.peers.delete(uid); }
  private disconnectPeers() { for (const [uid,peer] of Array.from(this.peers)) this.closePeer(uid,peer); }
  stop() { this.alive=false;clearTimeout(this.timer);this.disconnectPeers();this.inbound.clear();this.released?.();this.store?.close();this.options.deviceControl?.close(); }
}
async function hash(data:ArrayBuffer) { return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256",data)),b=>b.toString(16).padStart(2,"0")).join(""); }
",
      "src/client.js": "import { LocalChatStore, toBase64, fromBase64 } from "./storage.js";
const MAX_FILE = 25 * 1024 * 1024;
const CHUNK = 12 * 1024;
const UUID = /^[a-f0-9-]{36}$/i;
export class DirectChatClient {
    options;
    pageId = crypto.randomUUID();
    store;
    snapshot;
    peers = new Map();
    inbound = new Map();
    timer;
    alive = false;
    polling = false;
    authenticatedAt = 0;
    nextSend = new Map();
    released;
    constructor(options) {
        this.options = options;
    }
    async api(path, body, method = "POST") {
        if (!this.alive)
            throw new Error("连接已结束，请重新打开聊天。");
        if (this.options.deviceControl)
            return this.options.deviceControl.request(path, body, method);
        const token = this.options.token();
        if (!token)
            throw new Error("请先连接自己的账号。");
        const response = await fetch(`${this.options.baseUrl.replace(/\/$/, "")}${path}`, {
            method, credentials: "omit", cache: "no-store", signal: AbortSignal.timeout(12000),
            headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
            body: body === undefined ? undefined : JSON.stringify(body),
        });
        if (!response.ok) {
            if (response.status === 401 || response.status === 403)
                this.disconnectPeers();
            const data = await response.json().catch(() => ({}));
            if (data.detail?.code === "device_replaced") {
                this.stop();
                throw new Error(data.detail.message);
            }
            throw new Error(typeof data.detail === "string" ? data.detail : `连接暂时未完成（${response.status}）。`);
        }
        return response.json();
    }
    async start() {
        if (this.alive)
            return;
        this.alive = true;
        try {
            const identity = await this.api("/identity", undefined, "GET");
            if (!this.alive)
                return;
            // One tab per account/origin owns a device node; other tabs never fight over signaling.
            if (navigator.locks)
                await new Promise((resolve, reject) => {
                    void navigator.locks.request(`zhuge-direct-im-${identity.id}`, { ifAvailable: true }, async (lock) => {
                        if (!lock) {
                            reject(new Error("此账号已在另一个窗口打开聊天，请先关闭那个窗口。"));
                            return;
                        }
                        resolve();
                        await new Promise(release => { this.released = release; });
                    });
                });
            this.store = new LocalChatStore(identity.id);
            await this.store.open();
            if (!this.alive) {
                this.store.close();
                this.released?.();
                return;
            }
            const first = await this.api("/poll", { page_id: this.pageId, activate: true });
            this.snapshot = first;
            this.authenticatedAt = Date.now();
            this.options.onChange?.();
            void navigator.storage?.persist?.().catch(() => false);
            await this.applySnapshot(first);
            this.schedule();
        }
        catch (error) {
            this.stop();
            throw error;
        }
    }
    schedule() { clearTimeout(this.timer); if (this.alive)
        this.timer = setTimeout(() => void this.poll(), 2500); }
    async poll() {
        if (!this.alive || this.polling)
            return;
        this.polling = true;
        try {
            const data = await this.api("/poll", { page_id: this.pageId });
            if (!this.alive)
                return;
            if (this.store?.account !== data.user.id) {
                this.stop();
                throw new Error("账号已改变，请重新打开聊天。");
            }
            this.authenticatedAt = Date.now();
            this.snapshot = data;
            await this.applySnapshot(data);
            this.options.onChange?.();
            for (const [key, value] of Array.from(this.inbound))
                if (Date.now() - value.touched > 60000)
                    this.inbound.delete(key);
        }
        catch (error) {
            this.notice(error);
        }
        finally {
            this.polling = false;
            this.schedule();
        }
    }
    notice(error) { this.options.onNotice?.(error instanceof Error ? error.message : "连接暂时不可用。"); }
    allowed(peer, conversation) {
        const c = this.snapshot?.conversations.find(c => c.id === conversation);
        const valid = this.options.deviceControl ? this.options.deviceControl.trusted(peer, conversation) : Date.now() - this.authenticatedAt < 120000;
        return valid && !!c?.participants.some(p => p.user_id === peer) && !!c.participants.some(p => p.user_id === this.store?.account);
    }
    async applySnapshot(data) {
        if (data.transport !== "direct_only")
            throw new Error("当前连接方式不符合设备直连要求。");
        const reachable = new Set(data.peers.map(l => l.peer_user_id));
        for (const [uid, peer] of Array.from(this.peers))
            if (!reachable.has(uid))
                this.closePeer(uid, peer);
        for (const link of data.peers) {
            let peer = this.peers.get(link.peer_user_id);
            if (peer && link.online && peer.link.peer_page_id !== link.peer_page_id) {
                this.closePeer(link.peer_user_id, peer);
                peer = undefined;
            }
            if (peer && !peer.ready && Date.now() - peer.started > 25000) {
                this.closePeer(link.peer_user_id, peer);
                peer = undefined;
            }
            // A failed presence request must not tear down an established direct connection.
            if (!peer && link.online) {
                peer = this.createPeer(link);
                if (data.user.id < link.peer_user_id) {
                    this.configureChannel(peer, peer.pc.createDataChannel("zhuge-im-v1", { ordered: true }));
                    const offer = await peer.pc.createOffer();
                    await peer.pc.setLocalDescription(offer);
                    await this.sendSignal(peer, "offer", { type: "offer", sdp: offer.sdp });
                }
            }
        }
        const ack = [];
        for (const signal of data.signals) {
            const peer = this.peers.get(signal.peer_user_id);
            if (!peer)
                continue;
            if (!peer.seen.has(signal.id)) {
                try {
                    await this.acceptSignal(peer, signal);
                    peer.seen.add(signal.id);
                }
                catch {
                    continue;
                }
            }
            ack.push(signal.id);
        }
        if (ack.length)
            await this.api("/signals/ack", { page_id: this.pageId, ids: ack });
        for (const peer of Array.from(this.peers.values()))
            if (peer.ready)
                void this.pump(peer);
        this.options.deviceControl?.connected(Array.from(this.peers).filter(([, p]) => p.ready).map(([uid]) => uid));
    }
    createPeer(link) {
        const ice = (this.snapshot?.ice_servers || []).map(s => ({ urls: (Array.isArray(s.urls) ? s.urls : [s.urls]).filter(u => u.startsWith("stun:")) })).filter(s => s.urls.length);
        const pc = new RTCPeerConnection({ iceServers: ice });
        const peer = { link, pc, channelId: crypto.randomUUID(), pending: [], ready: false, queue: Promise.resolve(), pumping: false, seen: new Set(), started: Date.now(), signalQueue: Promise.resolve() };
        this.peers.set(link.peer_user_id, peer);
        pc.onicecandidate = e => { if (e.candidate) {
            const c = e.candidate.toJSON();
            void this.sendSignal(peer, "ice", { candidate: c.candidate, sdpMid: c.sdpMid, sdpMLineIndex: c.sdpMLineIndex }).catch(error => this.notice(error));
        } };
        pc.ondatachannel = e => this.configureChannel(peer, e.channel);
        pc.onconnectionstatechange = () => { if (["failed", "closed"].includes(pc.connectionState)) {
            peer.ready = false;
            this.options.onChange?.();
        } };
        return peer;
    }
    async sendSignal(peer, type, signal) {
        if (!this.alive)
            return;
        const send = () => this.api("/signals", { page_id: this.pageId, peer_user_id: peer.link.peer_user_id,
            peer_page_id: peer.link.peer_page_id, channel_id: peer.channelId, signal_type: type, signal }).then(() => undefined);
        peer.signalQueue = peer.signalQueue.then(send);
        return peer.signalQueue;
    }
    async acceptSignal(peer, signal) {
        if (signal.signal_type === "offer") {
            if (this.store.account < peer.link.peer_user_id)
                return;
            if (peer.pc.signalingState !== "stable" || peer.pc.remoteDescription)
                return;
            peer.channelId = signal.channel_id;
            await peer.pc.setRemoteDescription(signal.signal);
            for (const c of peer.pending.splice(0))
                await peer.pc.addIceCandidate(c);
            const answer = await peer.pc.createAnswer();
            await peer.pc.setLocalDescription(answer);
            await this.sendSignal(peer, "answer", { type: "answer", sdp: answer.sdp });
        }
        else if (signal.signal_type === "answer") {
            if (signal.channel_id !== peer.channelId || peer.pc.signalingState !== "have-local-offer")
                return;
            await peer.pc.setRemoteDescription(signal.signal);
            for (const c of peer.pending.splice(0))
                await peer.pc.addIceCandidate(c);
        }
        else {
            if (this.store.account < peer.link.peer_user_id && signal.channel_id !== peer.channelId)
                return;
            if (peer.pc.remoteDescription)
                await peer.pc.addIceCandidate(signal.signal);
            else
                peer.pending.push(signal.signal);
        }
    }
    configureChannel(peer, channel) {
        if (channel.label !== "zhuge-im-v1" || peer.channel) {
            channel.close();
            return;
        }
        peer.channel = channel;
        channel.onopen = async () => {
            const stats = await peer.pc.getStats();
            let relay = false;
            stats.forEach(s => { if ((s.type === "local-candidate" || s.type === "remote-candidate") && s.candidateType === "relay")
                relay = true; });
            if (relay) {
                this.closePeer(peer.link.peer_user_id, peer);
                this.notice(new Error("已停止中继连接，请使用可直连网络。"));
                return;
            }
            peer.ready = true;
            this.options.onChange?.();
            void this.pump(peer);
        };
        channel.onclose = channel.onerror = () => { peer.ready = false; this.options.onChange?.(); };
        channel.onmessage = event => {
            if (typeof event.data !== "string" || event.data.length > 24000)
                return;
            // Preserve wire order across asynchronous IndexedDB/hash operations.
            peer.queue = peer.queue.then(() => this.receive(peer, JSON.parse(event.data))).catch(error => this.notice(error));
        };
    }
    async write(peer, value) {
        const channel = peer.channel;
        if (!this.alive || !channel || channel.readyState !== "open")
            throw new Error("对方暂时离线，消息会留在本机等待重连。");
        const started = Date.now();
        while (channel.bufferedAmount > 256 * 1024) {
            if (Date.now() - started > 15000 || channel.readyState !== "open" || !this.alive)
                throw new Error("文件传输中断，正在等待重连。");
            await new Promise(resolve => setTimeout(resolve, 25));
        }
        channel.send(JSON.stringify(value));
    }
    async pump(peer) {
        if (peer.pumping || !this.store)
            return;
        peer.pumping = true;
        try {
            const records = await this.store.list();
            for (const r of records) {
                const key = `${r.direct_id}:${peer.link.peer_user_id}`;
                if (!r.is_mine || !r.recipient_ids.includes(peer.link.peer_user_id) || r.delivered_to.includes(peer.link.peer_user_id) || !this.allowed(peer.link.peer_user_id, r.conversation_id) || (this.nextSend.get(key) || 0) > Date.now())
                    continue;
                this.nextSend.set(key, Date.now() + 30000);
                const wire = { type: "message", version: 1, id: r.direct_id, conversation_id: r.conversation_id,
                    sender_user_id: r.sender_user_id, content: r.content, message_type: r.message_type, created_at: r.created_at, metadata_json: r.metadata_json };
                await this.write(peer, wire);
                if (r.message_type === "file") {
                    const file = await this.store.file(r.direct_id);
                    if (!file)
                        throw new Error("待发文件已不在本机，请重新选择文件。");
                    const data = new Uint8Array(file);
                    for (let start = 0; start < data.length; start += CHUNK)
                        await this.write(peer, { type: "chunk", id: r.direct_id, index: start / CHUNK, data: toBase64(data.subarray(start, start + CHUNK)) });
                }
            }
        }
        catch (error) {
            this.notice(error);
        }
        finally {
            peer.pumping = false;
        }
    }
    validMessage(value, peer) {
        if (value.version !== 1 || !UUID.test(value.id) || value.sender_user_id !== peer.link.peer_user_id || !this.allowed(peer.link.peer_user_id, value.conversation_id))
            return false;
        if (typeof value.content !== "string" || value.content.length > 4000 || typeof value.created_at !== "string" || value.created_at.length > 40 || !["text", "file", "location", "call"].includes(value.message_type))
            return false;
        if (!value.metadata_json || typeof value.metadata_json !== "object" || JSON.stringify(value.metadata_json).length > 2000)
            return false;
        return true;
    }
    async receive(peer, value) {
        if (!this.store || !this.alive)
            return;
        const kind = value.type;
        if (kind === "ack") {
            await this.store.exclusive(async () => {
                const r = await this.store.find(value.id);
                if (!r?.is_mine || !r.recipient_ids.includes(peer.link.peer_user_id) || r.delivered_to.includes(peer.link.peer_user_id))
                    return;
                r.delivered_to.push(peer.link.peer_user_id);
                r.local_status = r.recipient_ids.every(id => r.delivered_to.includes(id)) ? "sent" : "sending";
                await this.store.save(r);
            });
            this.options.onChange?.();
            return;
        }
        if (kind === "message") {
            if (!this.validMessage(value, peer))
                return;
            const existing = await this.store.find(value.id);
            if (existing) {
                if (existing.sender_user_id === value.sender_user_id && existing.conversation_id === value.conversation_id && existing.content === value.content)
                    await this.write(peer, { type: "ack", id: value.id });
                return;
            }
            if (value.message_type === "file") {
                const a = value.metadata_json.attachment;
                if (!a || !Number.isSafeInteger(a.size) || a.size < 1 || a.size > MAX_FILE || typeof a.original_name !== "string" || a.original_name.length > 240 || !/^[a-f0-9]{64}$/.test(a.sha256))
                    return;
                if (this.inbound.size >= 4 && !this.inbound.has(value.id))
                    return;
                this.inbound.set(value.id, { message: value, parts: [], received: 0, chunks: 0, touched: Date.now() });
                return;
            }
            await this.acceptMessage(peer, value);
            return;
        }
        if (kind === "chunk") {
            const transfer = this.inbound.get(value.id);
            if (!transfer || transfer.message.sender_user_id !== peer.link.peer_user_id || !this.allowed(peer.link.peer_user_id, transfer.message.conversation_id) || value.index !== transfer.chunks || typeof value.data !== "string" || value.data.length > CHUNK * 4 / 3)
                return;
            const chunk = fromBase64(value.data);
            const a = transfer.message.metadata_json.attachment;
            if (!chunk.length || transfer.received + chunk.length > a.size) {
                this.inbound.delete(value.id);
                return;
            }
            transfer.parts.push(chunk);
            transfer.received += chunk.length;
            transfer.chunks++;
            transfer.touched = Date.now();
            if (transfer.received === a.size) {
                const file = new Blob(transfer.parts);
                if (await hash(await file.arrayBuffer()) !== a.sha256) {
                    this.inbound.delete(value.id);
                    throw new Error("文件校验失败，未保存文件。");
                }
                await this.store.saveFile(value.id, file);
                await this.acceptMessage(peer, transfer.message);
                this.inbound.delete(value.id);
            }
        }
    }
    async acceptMessage(peer, wire) {
        await this.store.exclusive(async () => {
            if (await this.store.find(wire.id))
                return;
            const members = this.snapshot.conversations.find(c => c.id === wire.conversation_id).participants;
            // Never trust a remote attachment URL or label for the sender identity.
            const metadata = {};
            if (wire.message_type === "file") {
                const a = wire.metadata_json.attachment;
                metadata.attachment = { original_name: String(a.original_name), size: Number(a.size), content_type: "application/octet-stream", sha256: String(a.sha256) };
            }
            if (wire.message_type === "location") {
                const p = wire.metadata_json.location;
                if (p && typeof p.latitude === "number" && Math.abs(p.latitude) <= 90 && typeof p.longitude === "number" && Math.abs(p.longitude) <= 180)
                    metadata.location = { latitude: p.latitude, longitude: p.longitude };
            }
            await this.store.save({ id: await this.store.nextId(), direct_id: wire.id, conversation_id: wire.conversation_id, sender_user_id: wire.sender_user_id,
                sender_name: members.find(p => p.user_id === wire.sender_user_id)?.display_name || "联系人", content: wire.content, message_type: wire.message_type, created_at: wire.created_at,
                metadata_json: metadata, recipient_ids: [], delivered_to: [], is_mine: false, local_status: "sent" });
        });
        this.options.onChange?.();
        await this.write(peer, { type: "ack", id: wire.id });
    }
    async send(conversation, content, messageType = "text", metadata = {}, file) {
        if (!this.alive || !this.store || !this.snapshot)
            throw new Error("连接已结束，请重新打开聊天。");
        const c = this.snapshot.conversations.find(c => c.id === conversation);
        if (!c || content.length > 4000 || !content.trim())
            throw new Error("请选择会话，消息不能超过 4000 个字。");
        const recipients = c.participants.map(p => p.user_id).filter(id => id !== this.store.account);
        if (!recipients.length || recipients.some(peer => !this.allowed(peer, conversation)))
            throw new Error("请重新连接并确认会话成员后发送。");
        const id = crypto.randomUUID();
        if (file) {
            if (!file.size || file.size > MAX_FILE)
                throw new Error("文件大小需在 1 字节至 25 MB 之间。");
            metadata = { attachment: { original_name: file.name.slice(0, 240), size: file.size, content_type: file.type || "application/octet-stream", sha256: await hash(await file.arrayBuffer()) } };
            await this.store.saveFile(id, file);
        }
        const record = await this.store.exclusive(async () => {
            const r = { id: await this.store.nextId(), direct_id: id, conversation_id: conversation, sender_user_id: this.store.account,
                sender_name: this.snapshot.user.display_name, content, message_type: messageType, created_at: new Date().toISOString(), metadata_json: metadata,
                recipient_ids: recipients, delivered_to: [], is_mine: true, local_status: "sending" };
            await this.store.save(r);
            return r;
        });
        this.options.onChange?.();
        for (const peer of Array.from(this.peers.values()))
            if (peer.ready)
                void this.pump(peer);
        return record;
    }
    async messages(conversation) {
        if (!this.store)
            return [];
        const rows = await this.store.list(conversation);
        return Promise.all(rows.map(async (r) => {
            if (r.message_type !== "file")
                return r;
            const a = r.metadata_json.attachment;
            const url = await this.store.fileUrl(r.direct_id, String(a.content_type || "application/octet-stream"));
            return { ...r, metadata_json: { ...r.metadata_json, attachment: { ...a, url } } };
        }));
    }
    async conversationViews(items) {
        if (!this.store)
            return items;
        const messages = await this.store.list();
        return Promise.all(items.map(async (c) => {
            const rows = messages.filter(r => r.conversation_id === c.id);
            const read = await this.store.readAt(c.id);
            const last = rows.at(-1);
            return { ...c, last_message: last || null, last_message_at: last?.created_at || null, unread_count: rows.filter(r => !r.is_mine && r.id > read).length };
        }));
    }
    status(conversation) {
        const ids = this.snapshot?.conversations.find(c => c.id === conversation)?.participants.filter(p => p.user_id !== this.store?.account).map(p => p.user_id) || [];
        const online = ids.filter(id => this.peers.get(id)?.ready).length;
        return online === ids.length && online > 0 ? "设备已直连" : online > 0 ? `${online}/${ids.length} 位成员已直连` : "等待对方上线或网络直连";
    }
    closePeer(uid, peer) { peer.channel?.close(); peer.pc.close(); this.peers.delete(uid); }
    disconnectPeers() { for (const [uid, peer] of Array.from(this.peers))
        this.closePeer(uid, peer); }
    stop() { this.alive = false; clearTimeout(this.timer); this.disconnectPeers(); this.inbound.clear(); this.released?.(); this.store?.close(); this.options.deviceControl?.close(); }
}
async function hash(data) { return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", data)), b => b.toString(16).padStart(2, "0")).join(""); }
",
      "src/storage.ts": "export type ChatRecord = {
  id: number; direct_id: string; conversation_id: number; sender_user_id: number;
  sender_name?: string; content: string; message_type: string; created_at: string;
  metadata_json: Record<string, unknown>; recipient_ids: number[]; delivered_to: number[];
  is_mine: boolean; local_status: "sending" | "sent";
};
type Cipher = { iv: ArrayBuffer; data: ArrayBuffer };
const bytes = new TextEncoder();
const text = new TextDecoder();
function done<T>(request: IDBRequest<T>): Promise<T> {
  return new Promise((resolve, reject) => { request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); });
}
function committed(tx: IDBTransaction): Promise<void> {
  return new Promise((resolve, reject) => { tx.oncomplete = () => resolve(); tx.onabort = tx.onerror = () => reject(tx.error || new Error("本机保存失败")); });
}
export async function encrypt(key: CryptoKey, input: ArrayBuffer): Promise<Cipher> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  return { iv: iv.buffer, data: await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, input) };
}
async function decrypt(key: CryptoKey, input: Cipher): Promise<ArrayBuffer> {
  return crypto.subtle.decrypt({ name: "AES-GCM", iv: input.iv }, key, input.data);
}
export class LocalChatStore {
  private db!: IDBDatabase;
  private key!: CryptoKey;
  private serial: Promise<unknown> = Promise.resolve();
  private urls = new Map<string, string>();
  constructor(readonly account: number) {}
  async open() {
    if (!Number.isSafeInteger(this.account) || this.account <= 0 || !crypto.subtle || !indexedDB) throw new Error("请登录并使用支持本地存储的安全浏览器。");
    const request = indexedDB.open(`zhuge-direct-im-v1-${this.account}`, 1);
    request.onupgradeneeded = () => { for (const name of ["keys", "messages", "files", "state"]) request.result.createObjectStore(name); };
    this.db = await done(request);
    this.db.onversionchange = () => this.close();
    const candidate = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
    const tx = this.db.transaction("keys", "readwrite");
    const ready = committed(tx);
    const store = tx.objectStore("keys");
    const existing = await done(store.get("local"));
    this.key = existing || candidate;
    if (!existing) store.put(candidate, "local");
    await ready;
  }
  private async get<T>(store: string, id: IDBValidKey): Promise<T | undefined> {
    return done(this.db.transaction(store).objectStore(store).get(id));
  }
  private async put(store: string, id: IDBValidKey, value: unknown) {
    const tx = this.db.transaction(store, "readwrite"); const result = committed(tx);
    tx.objectStore(store).put(value, id); await result;
  }
  exclusive<T>(job: () => Promise<T>): Promise<T> {
    const result = this.serial.then(job); this.serial = result.catch(() => undefined); return result;
  }
  async find(id: string): Promise<ChatRecord | undefined> {
    const value = await this.get<Cipher>("messages", id);
    return value ? JSON.parse(text.decode(await decrypt(this.key, value))) : undefined;
  }
  async save(record: ChatRecord) {
    await this.put("messages", record.direct_id, await encrypt(this.key, bytes.encode(JSON.stringify(record)).buffer));
  }
  async nextId() {
    const old = await this.get<number>("state", "counter") || 0;
    const id = Math.max(Date.now() * 1000, old + 1);
    await this.put("state", "counter", id); return id;
  }
  async list(conversation?: number): Promise<ChatRecord[]> {
    const all: Cipher[] = await done(this.db.transaction("messages").objectStore("messages").getAll());
    const records = await Promise.all(all.map(async value => JSON.parse(text.decode(await decrypt(this.key, value))) as ChatRecord));
    return records.filter(r => conversation === undefined || r.conversation_id === conversation).sort((a,b) => a.id-b.id);
  }
  async saveFile(id: string, file: Blob) { await this.put("files", id, await encrypt(this.key, await file.arrayBuffer())); }
  async file(id: string): Promise<ArrayBuffer | undefined> { const f = await this.get<Cipher>("files", id); return f ? decrypt(this.key, f) : undefined; }
  async fileUrl(id: string, type: string): Promise<string | undefined> {
    if (this.urls.has(id)) return this.urls.get(id);
    const data = await this.file(id); if (!data) return undefined;
    const url = URL.createObjectURL(new Blob([data], { type })); this.urls.set(id, url); return url;
  }
  async markRead(conversation: number) { const records = await this.list(conversation); await this.put("state", `read-${conversation}`, records.at(-1)?.id || 0); }
  async readAt(conversation: number) { return await this.get<number>("state", `read-${conversation}`) || 0; }
  async persistPreference(name: string, value: unknown) { await this.put("state", name, value); }
  async preference<T>(name: string) { return this.get<T>("state", name); }
  async backup(passphrase: string): Promise<Blob> {
    if (passphrase.length < 10) throw new Error("备份密码至少需要 10 个字符。");
    const salt = crypto.getRandomValues(new Uint8Array(16));
    const base = await crypto.subtle.importKey("raw", bytes.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
    const key = await crypto.subtle.deriveKey({ name: "PBKDF2", salt, iterations: 250000, hash: "SHA-256" }, base, { name: "AES-GCM", length: 256 }, false, ["encrypt"]);
    const records = await this.list();
    const files: Record<string, string> = {};
    for (const r of records.filter(r => r.message_type === "file")) { const data = await this.file(r.direct_id); if (data) files[r.direct_id] = toBase64(new Uint8Array(data)); }
    const result = await encrypt(key, bytes.encode(JSON.stringify({ version: 1, account: this.account, records, files })).buffer);
    return new Blob([JSON.stringify({ format: "zhuge-direct-im-backup-v1", salt: toBase64(salt), iv: toBase64(new Uint8Array(result.iv)), data: toBase64(new Uint8Array(result.data)) })], { type: "application/json" });
  }
  async restore(file: File, passphrase: string) {
    if (file.size > 256 * 1024 * 1024) throw new Error("此备份过大，请分批恢复。");
    try {
      const envelope = JSON.parse(await file.text());
      if (envelope.format !== "zhuge-direct-im-backup-v1") throw new Error();
      const base = await crypto.subtle.importKey("raw", bytes.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
      const key = await crypto.subtle.deriveKey({ name: "PBKDF2", salt: fromBase64(envelope.salt), iterations: 250000, hash: "SHA-256" }, base, { name: "AES-GCM", length: 256 }, false, ["decrypt"]);
      const data = JSON.parse(text.decode(await decrypt(key, { iv: fromBase64(envelope.iv).buffer, data: fromBase64(envelope.data).buffer })));
      if (data.version !== 1 || data.account !== this.account || !Array.isArray(data.records) || !data.files || typeof data.files !== "object") throw new Error();
      const identifiers = new Set<string>();
      for (const record of data.records as ChatRecord[]) {
        if (!record || !/^[a-f0-9-]{36}$/i.test(record.direct_id) || identifiers.has(record.direct_id)
          || !Number.isSafeInteger(record.conversation_id) || record.conversation_id <= 0
          || !Number.isSafeInteger(record.sender_user_id) || record.sender_user_id <= 0
          || typeof record.content !== "string" || record.content.length > 4000
          || !["text","file","location","call"].includes(record.message_type)
          || !Number.isFinite(Date.parse(record.created_at)) || !record.metadata_json || typeof record.metadata_json !== "object") throw new Error();
        identifiers.add(record.direct_id);
        if (record.message_type === "file" && typeof data.files[record.direct_id] !== "string") throw new Error();
      }
      // Restored outgoing records are history, not a command to send to former contacts again.
      await this.exclusive(async () => {
        const staged: { id: string; record: Cipher; file?: Cipher }[] = [];
        let counter = Math.max(Date.now()*1000, (await this.get<number>("state", "counter") || 0)+1);
        for (const record of data.records as ChatRecord[]) {
          if (await this.find(record.direct_id)) continue;
          const fileBytes = record.message_type === "file" ? fromBase64(data.files[record.direct_id]) : undefined;
          if (fileBytes && fileBytes.length > 25*1024*1024) throw new Error();
          const restored = { ...record, id: counter++, is_mine: record.sender_user_id === this.account, recipient_ids: [], delivered_to: [], local_status: "sent" };
          staged.push({id:record.direct_id, record:await encrypt(this.key, bytes.encode(JSON.stringify(restored)).buffer), file:fileBytes ? await encrypt(this.key,fileBytes.buffer) : undefined});
        }
        // Encrypt and validate everything before opening the single atomic write transaction.
        const tx = this.db.transaction(["messages", "files", "state"], "readwrite");
        const ready = committed(tx);
        const messages = tx.objectStore("messages");
        for (const item of staged) {
          if (await done(messages.get(item.id))) continue;
          messages.put(item.record,item.id);
          if (item.file) tx.objectStore("files").put(item.file,item.id);
        }
        const state = tx.objectStore("state");
        state.put(Math.max(counter, (await done(state.get("counter"))) || 0), "counter");
        await ready;
      });
    } catch { throw new Error("备份密码、文件或所属账号不正确，未恢复该备份。"); }
  }
  close() { for (const url of Array.from(this.urls.values())) URL.revokeObjectURL(url); this.urls.clear(); this.db?.close(); }
}
export function toBase64(data: Uint8Array): string {
  let result = ""; for (let i=0;i<data.length;i+=8192) result += String.fromCharCode(...Array.from(data.subarray(i,i+8192))); return btoa(result);
}
export function fromBase64(value: string): Uint8Array<ArrayBuffer> { return Uint8Array.from(atob(value), c => c.charCodeAt(0)); }
",
      "src/storage.js": "const bytes = new TextEncoder();
const text = new TextDecoder();
function done(request) {
    return new Promise((resolve, reject) => { request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); });
}
function committed(tx) {
    return new Promise((resolve, reject) => { tx.oncomplete = () => resolve(); tx.onabort = tx.onerror = () => reject(tx.error || new Error("本机保存失败")); });
}
export async function encrypt(key, input) {
    const iv = crypto.getRandomValues(new Uint8Array(12));
    return { iv: iv.buffer, data: await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, input) };
}
async function decrypt(key, input) {
    return crypto.subtle.decrypt({ name: "AES-GCM", iv: input.iv }, key, input.data);
}
export class LocalChatStore {
    account;
    db;
    key;
    serial = Promise.resolve();
    urls = new Map();
    constructor(account) {
        this.account = account;
    }
    async open() {
        if (!Number.isSafeInteger(this.account) || this.account <= 0 || !crypto.subtle || !indexedDB)
            throw new Error("请登录并使用支持本地存储的安全浏览器。");
        const request = indexedDB.open(`zhuge-direct-im-v1-${this.account}`, 1);
        request.onupgradeneeded = () => { for (const name of ["keys", "messages", "files", "state"])
            request.result.createObjectStore(name); };
        this.db = await done(request);
        this.db.onversionchange = () => this.close();
        const candidate = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
        const tx = this.db.transaction("keys", "readwrite");
        const ready = committed(tx);
        const store = tx.objectStore("keys");
        const existing = await done(store.get("local"));
        this.key = existing || candidate;
        if (!existing)
            store.put(candidate, "local");
        await ready;
    }
    async get(store, id) {
        return done(this.db.transaction(store).objectStore(store).get(id));
    }
    async put(store, id, value) {
        const tx = this.db.transaction(store, "readwrite");
        const result = committed(tx);
        tx.objectStore(store).put(value, id);
        await result;
    }
    exclusive(job) {
        const result = this.serial.then(job);
        this.serial = result.catch(() => undefined);
        return result;
    }
    async find(id) {
        const value = await this.get("messages", id);
        return value ? JSON.parse(text.decode(await decrypt(this.key, value))) : undefined;
    }
    async save(record) {
        await this.put("messages", record.direct_id, await encrypt(this.key, bytes.encode(JSON.stringify(record)).buffer));
    }
    async nextId() {
        const old = await this.get("state", "counter") || 0;
        const id = Math.max(Date.now() * 1000, old + 1);
        await this.put("state", "counter", id);
        return id;
    }
    async list(conversation) {
        const all = await done(this.db.transaction("messages").objectStore("messages").getAll());
        const records = await Promise.all(all.map(async (value) => JSON.parse(text.decode(await decrypt(this.key, value)))));
        return records.filter(r => conversation === undefined || r.conversation_id === conversation).sort((a, b) => a.id - b.id);
    }
    async saveFile(id, file) { await this.put("files", id, await encrypt(this.key, await file.arrayBuffer())); }
    async file(id) { const f = await this.get("files", id); return f ? decrypt(this.key, f) : undefined; }
    async fileUrl(id, type) {
        if (this.urls.has(id))
            return this.urls.get(id);
        const data = await this.file(id);
        if (!data)
            return undefined;
        const url = URL.createObjectURL(new Blob([data], { type }));
        this.urls.set(id, url);
        return url;
    }
    async markRead(conversation) { const records = await this.list(conversation); await this.put("state", `read-${conversation}`, records.at(-1)?.id || 0); }
    async readAt(conversation) { return await this.get("state", `read-${conversation}`) || 0; }
    async persistPreference(name, value) { await this.put("state", name, value); }
    async preference(name) { return this.get("state", name); }
    async backup(passphrase) {
        if (passphrase.length < 10)
            throw new Error("备份密码至少需要 10 个字符。");
        const salt = crypto.getRandomValues(new Uint8Array(16));
        const base = await crypto.subtle.importKey("raw", bytes.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
        const key = await crypto.subtle.deriveKey({ name: "PBKDF2", salt, iterations: 250000, hash: "SHA-256" }, base, { name: "AES-GCM", length: 256 }, false, ["encrypt"]);
        const records = await this.list();
        const files = {};
        for (const r of records.filter(r => r.message_type === "file")) {
            const data = await this.file(r.direct_id);
            if (data)
                files[r.direct_id] = toBase64(new Uint8Array(data));
        }
        const result = await encrypt(key, bytes.encode(JSON.stringify({ version: 1, account: this.account, records, files })).buffer);
        return new Blob([JSON.stringify({ format: "zhuge-direct-im-backup-v1", salt: toBase64(salt), iv: toBase64(new Uint8Array(result.iv)), data: toBase64(new Uint8Array(result.data)) })], { type: "application/json" });
    }
    async restore(file, passphrase) {
        if (file.size > 256 * 1024 * 1024)
            throw new Error("此备份过大，请分批恢复。");
        try {
            const envelope = JSON.parse(await file.text());
            if (envelope.format !== "zhuge-direct-im-backup-v1")
                throw new Error();
            const base = await crypto.subtle.importKey("raw", bytes.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
            const key = await crypto.subtle.deriveKey({ name: "PBKDF2", salt: fromBase64(envelope.salt), iterations: 250000, hash: "SHA-256" }, base, { name: "AES-GCM", length: 256 }, false, ["decrypt"]);
            const data = JSON.parse(text.decode(await decrypt(key, { iv: fromBase64(envelope.iv).buffer, data: fromBase64(envelope.data).buffer })));
            if (data.version !== 1 || data.account !== this.account || !Array.isArray(data.records) || !data.files || typeof data.files !== "object")
                throw new Error();
            const identifiers = new Set();
            for (const record of data.records) {
                if (!record || !/^[a-f0-9-]{36}$/i.test(record.direct_id) || identifiers.has(record.direct_id)
                    || !Number.isSafeInteger(record.conversation_id) || record.conversation_id <= 0
                    || !Number.isSafeInteger(record.sender_user_id) || record.sender_user_id <= 0
                    || typeof record.content !== "string" || record.content.length > 4000
                    || !["text", "file", "location", "call"].includes(record.message_type)
                    || !Number.isFinite(Date.parse(record.created_at)) || !record.metadata_json || typeof record.metadata_json !== "object")
                    throw new Error();
                identifiers.add(record.direct_id);
                if (record.message_type === "file" && typeof data.files[record.direct_id] !== "string")
                    throw new Error();
            }
            // Restored outgoing records are history, not a command to send to former contacts again.
            await this.exclusive(async () => {
                const staged = [];
                let counter = Math.max(Date.now() * 1000, (await this.get("state", "counter") || 0) + 1);
                for (const record of data.records) {
                    if (await this.find(record.direct_id))
                        continue;
                    const fileBytes = record.message_type === "file" ? fromBase64(data.files[record.direct_id]) : undefined;
                    if (fileBytes && fileBytes.length > 25 * 1024 * 1024)
                        throw new Error();
                    const restored = { ...record, id: counter++, is_mine: record.sender_user_id === this.account, recipient_ids: [], delivered_to: [], local_status: "sent" };
                    staged.push({ id: record.direct_id, record: await encrypt(this.key, bytes.encode(JSON.stringify(restored)).buffer), file: fileBytes ? await encrypt(this.key, fileBytes.buffer) : undefined });
                }
                // Encrypt and validate everything before opening the single atomic write transaction.
                const tx = this.db.transaction(["messages", "files", "state"], "readwrite");
                const ready = committed(tx);
                const messages = tx.objectStore("messages");
                for (const item of staged) {
                    if (await done(messages.get(item.id)))
                        continue;
                    messages.put(item.record, item.id);
                    if (item.file)
                        tx.objectStore("files").put(item.file, item.id);
                }
                const state = tx.objectStore("state");
                state.put(Math.max(counter, (await done(state.get("counter"))) || 0), "counter");
                await ready;
            });
        }
        catch {
            throw new Error("备份密码、文件或所属账号不正确，未恢复该备份。");
        }
    }
    close() { for (const url of Array.from(this.urls.values()))
        URL.revokeObjectURL(url); this.urls.clear(); this.db?.close(); }
}
export function toBase64(data) {
    let result = "";
    for (let i = 0; i < data.length; i += 8192)
        result += String.fromCharCode(...Array.from(data.subarray(i, i + 8192)));
    return btoa(result);
}
export function fromBase64(value) { return Uint8Array.from(atob(value), c => c.charCodeAt(0)); }
"
    }
  },
  "signature": "Z7ps1sCT5T5Zkpn37HkIIdjurtklazgH/LnO/YdFO+8DJozaJJolbjpgKptl9QjviBHCk0TDJdD6R5b/fr/pUWj6tIKAQ5AAlOBbm0k83b5uL8Rd+aFOyy0RBO4ND9TwSF1gGal8jm3+YsqG5UhzMzwIvLX+XDyEnr92sAuFGY/WPBKC+Sa37BPe7gnOqOJ81NIm4uswWpkrdDvb5V6/FUDWF3WGtKnw04JkVu89A5tWJ0vE9Ey9Zoi0LD7uP+cAsNJFKEMEqB6gY5ykpxqVjIAwSBsH1+SfeKYY9lBeoC3bCIufuyBFs82vYcwyOuFL+VUElTMMpZQjdNDIBiUrREynyVjAg3wip+kYlr8X0oVIB8lJiDj0OnfWLxUeE7qsN7+swSBRh9Ck2HMYK7VaSaq6n7ZOGwZ60raKe3+BYlcxXMe2zlM6f11vkNFcV6b7PYqGfvHIMVhGGViRGSMTA4lZCEFaOK5ir/EyHDlWUc80Sblg2mXtgLD/W+XUzFmX"
}