{
  "payload": {
    "version": "1.1.0",
    "protocol": "zhuge-im-v1",
    "api_major": 1,
    "storage_version": 1,
    "files": {
      "bootstrap.js": "7635493d28fcbfb0188db95596cb7177be9eda49d19ea944198eb308bd964713",
      "build.mjs": "45feb781439cc3de4b2ff7d497ad1972cefc4a76dfa403b81ca6810656b75c1f",
      "config.js": "36946cf75ff79b62e6606147425b58d10dc11df2cff31d39b9508135b2a30411",
      "extension-host.js": "3d6c9480a79f8f2d489e8158d977404131c9808aba5fc6d417366a0ad5fcd9df",
      "extension-schema.js": "5ce6a6d9c2f857ff57712974f7832872d0093f4b3944a022cba8dedbc3a6a214",
      "extension-worker.js": "3159ffbc7b7ca6099308b8161acfeef0839113321bb13ad0cb34953525d4fc02",
      "extensions-page.js": "2da43a47c8e7df6ecf05b239f2f214fbb7b1a63d6b4103183301c3ef51221f9a",
      "guard.mjs": "edd71cb2b6f6a729bc123649dba2201531145ba8fadb32c80c20ddceeb2413fe",
      "integrity.js": "19a593743549d4963b15d1b28cd85162687b46ed84b778becb2adf71682ad8d1",
      "recovery.html": "a56c1f38279f9e4614403332d9fafef47a779778d166da9e6991313f04f82818",
      "recovery.js": "759f3c2549a71684707cb8c1bcd2cdb12f8355aa43cf6a774e258816eb7ccca9",
      "release-key.json": "fac5a606b5a942538f373ca29639d998405f0b794a323c8577c8a55456906962",
      "sdk.js": "be567531a67b8204931ba3ec83d547149b4bddacaa87fcba06b17e37b18586cd",
      "server.mjs": "da3121afb2ed37bf5569351e9834ce9962c570611dde0dd9cf800c8fb5871b13",
      "src/client.ts": "e72c907dfc37cb6c336957eda5d9cb1d11d0a88eb0489f1c26298d156e4b9e3e",
      "src/client.js": "63e8c1a60be59d216410dd9235823de1b6d1ede0d6dd754c587cbd12d69b36d1",
      "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;}
}
",
      "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": "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",
      "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; 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>; 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 DirectOptions = { baseUrl: string; token: () => string; onChange?: () => void; onNotice?: (text: string) => void };

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("连接已结束，请重新打开聊天。");
    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);
    return Date.now()-this.authenticatedAt < 120000 && !!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[] = [];
    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);
  }
  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 || Date.now()-this.authenticatedAt>120000) 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(); }
}
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("连接已结束，请重新打开聊天。");
        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);
        return Date.now() - this.authenticatedAt < 120000 && !!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);
    }
    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 || Date.now() - this.authenticatedAt > 120000)
            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(); }
}
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": "eiqKthmMNmaZXELnOTj3ZCZ/iFu5fgdLbeF0gxzaN3YDF/GMll9YgCCDY/qJluKj6AslPD8vkbhmDmcVOS2k8DdNm9aX/Wr7ZnrscNdflkMnPKn8iDDa2y0cSXT3iAdbKi6pzCsDrILc6W64wG4vbGOpf0jcj0uM8ir8oaN5OfKsm/h+DCgF9iv2PIexBrEZ3B2AcUB9Cdu0VMw4r5Y0rLnK7luHsNJc8AUFjhyXfk7pqeb7uYauXrJqKYyrQNJGvMdhDwYdXvnlmT/9qQC+jNvdOMkICONJWdUeX46mNJZqXoACsO+0M975/lod13j4aO6Sg6j+j94JaRjJLQomw6cVDWpqM1VJ40WPwjNDDLesSk0YcFv0Sr7UGSkBi0TvSXl4lcbki5PbzCcNYzhs8eIMlcoG5659pq4miuh598qw9HD/lyW4WpYF8DDnsy3F99ZMICODvdP0UIEOI4UyUnRzMc/f+cmpN1pZZBhJ07jRZR16muLrvFZj/O+Jp/0r"
}