import {
  spawnSync
} from 'node:child_process';
import * as c from './common.mjs';
export * from './common.mjs';
const {
  fs,
  path,
  os,
  fail,
  small,
  zigzag,
  cat,
  matches,
  escapeRE,
  sha256,
  sha256_file,
  atomic_json,
  dict
} =c;
export const ENUM_TYPES=new Set(['AvatarPropertyType', 'OfferingRewardType', 'GridFightActivationType', 'GridFightChargeType', 'GridFightPreset', 'GridFightPropertyBindType', 'GridFightRoleSkillTag', 'GridFightTrailLayerQuality', 'GridFightTraitType', 'GridFightNodeType'].map(n=>'RPG.GameCore.'+n));
const ENUM_PROOFS=new Set();
export class Cursor {
  constructor(data, at=0){
    this.data=data;
    this.at=at;
  }
  varint(){
    let v=0n;
    for(let shift=0n; shift<70n; shift+=7n){
      if(this.at>=this.data.length)fail('truncated varint');
      const byte=this.data[this.at++];
      if(shift===63n&&byte>1)fail('varint overflow');
      v|=BigInt(byte&127)<<shift;
      if(byte<128)return small(v);
    }
    fail('varint overflow');
  }
  length(limit=10000){
    const v=BigInt(this.varint());
    if((v&1n)||v/2n>BigInt(limit))fail('invalid collection header');
    return Number(v/2n);
  }
}
export function pe_method(assembly, rva, size=8192){
  const fd=fs.openSync(assembly, 'r');
  try{
    const h=Buffer.alloc(64);
    fs.readSync(fd, h, 0, 64, 0);
    const pe=h.readUInt32LE(60),
    head=Buffer.alloc(264);
    fs.readSync(fd, head, 0, 264, pe);
    if(head.subarray(0, 4).toString('hex')!=='50450000')fail('invalid PE');
    const count=head.readUInt16LE(6),
    sections=pe+24+head.readUInt16LE(20),
    base=head.readBigUInt64LE(48),
    s=Buffer.alloc(count*40);
    fs.readSync(fd, s, 0, s.length, sections);
    for(let i=0; i<count; i++){
      const at=i*40+8,
      vs=s.readUInt32LE(at),
      start=s.readUInt32LE(at+4),
      rs=s.readUInt32LE(at+8),
      raw=s.readUInt32LE(at+12);
      if(start<=rva&&rva<start+Math.min(vs, rs)){
        const b=Buffer.alloc(Math.min(size, rs-(rva-start)));
        fs.readSync(fd, b, 0, b.length, raw+rva-start);
        return [base+BigInt(rva), b];
      }
    }
    fail('method RVA outside PE sections');
  } finally{
    fs.closeSync(fd);
  }
}
export function disassemble(assembly, rva, size){
  const [address, code]=pe_method(assembly, rva, size),
  dir=fs.mkdtempSync(path.join(os.tmpdir(), 'gf-dis-')),
  tmp=path.join(dir, 'code');
  try{
    fs.writeFileSync(tmp, code);
    const p=spawnSync('objdump', ['-D', '-b', 'binary', '-m', 'i386:x86-64', '-Mintel', `--adjust-vma=${address}`, tmp], {
      encoding:'utf8',
      maxBuffer:16*1024*1024
    });
    if(p.status!==0)fail(p.error?.message??p.stderr);
    return [address, p.stdout];
  } finally{
    fs.rmSync(dir, {
      recursive:true,
      force:true
    });
  }
}
export function schema(dump, assembly, name, evidence_dir){
  const match=dump.match(new RegExp('// Full Name: RPG.GameCore\\.'+escapeRE(name)+'\\n(.*?)(?=\\n// TypeDefIndex:|$)', 's'));
  if(!match)fail('missing client schema '+name);
  const block=match[1],
  fields=new Map(matches(block, /^    public ([\w.<>\[\]]+) (\w+) \/\/ Offset: (0x[\da-fA-F]+)/gm).map(m=>[Number(m[3]), [m[2], m[1]]]));
  const method=block.match(/public static void FromBinary\([^\n]+RVA: (0x[\da-fA-F]+)/);
  if(!fields.size||!method)fail('no binary reader for '+name);
  const rva=Number(method[1]),
  next=matches(dump, /RVA: (0x[\da-fA-F]+)/g).map(m=>Number(m[1])).filter(v=>rva<v&&v<=rva+8192);
  const [address, dis]=disassemble(assembly, rva, next.length?Math.min(...next)-rva:8192),
  tests=matches(dis, /test\s+(?:bl|ebx|rbx),0x([\da-f]+)/g),
  ordered=new Map();
  for(let i=0; i<tests.length; i++){
    const m=tests[i],
    bit=BigInt('0x'+m[1]);
    if(!bit||(bit&(bit-1n)))continue;
    const part=dis.slice(m.index+m[0].length, tests[i+1]?.index??dis.length);
    const offsets=[...matches(part, /mov\s+(?:BYTE|DWORD|QWORD) PTR \[(?:rsi|rdi)\+0x([\da-f]+)\],(?:al|eax|rax|esi|rsi)/g), ...matches(part, /add\s+(?:rdi|rsi),0x([\da-f]+)/g)];
    const found=new Set(offsets.map(x=>parseInt(x[1], 16)).filter(x=>fields.has(x)));
    if(found.size!==1){
      if(ordered.size===fields.size)break;
      fail(`${name}: cannot prove field order for mask 0x${bit.toString(16)}`);
    }
    const [field_name, field_type]=fields.get([...found][0]);
    if(ENUM_TYPES.has(field_type)){
      const en=dump.match(new RegExp('// Full Name: '+escapeRE(field_type)+'\\n(.*?)(?=\\n// TypeDefIndex:|$)', 's'));
      if(!en||!/public int value__/.test(en[1]))fail(field_type+': unsupported enum storage');
      const reader=part.match(/mov\s+rdx,(?:rsi|rdi)[^\n]*\n[^\n]*call\s+(0x[\da-f]+)/);
      if(!reader)fail(field_type+': enum reader not proved');
      const rr=Number(BigInt(reader[1])-(address-BigInt(rva))),
      pk=[assembly, rr, evidence_dir].join(':');
      if(!ENUM_PROOFS.has(pk)){
        const [, ed]=disassemble(assembly, rr, 1104);
        if(![/shr\s+ebx,1/, /and\s+esi,0x1/, /neg\s+esi/, /xor\s+ebx,esi/].every(r=>r.test(ed)))fail('native enum codec changed');
        fs.mkdirSync(evidence_dir, {
          recursive:true
        });
        fs.writeFileSync(path.join(evidence_dir, `EnumReader_${rr.toString(16)}.asm`), ed.slice(ed.indexOf('Disassembly')));
        ENUM_PROOFS.add(pk);
      }
    }
    ordered.set(bit.toString(2).length-1, {
      name:field_name,
      type:field_type
    });
    if(ordered.size===fields.size)break;
  }
  if(!ordered.size||!Array.from({
    length:ordered.size
  }, (_, i)=>ordered.has(i)).every(Boolean))fail(name+': incomplete native schema');
  fs.mkdirSync(evidence_dir, {
    recursive:true
  });
  fs.writeFileSync(path.join(evidence_dir, name+'.asm'), dis.slice(dis.indexOf('Disassembly of section .data:')));
  return Array.from({
    length:ordered.size
  }, (_, i)=>ordered.get(i));
}
export function field(cursor, typ, schemas){
  if(typ.endsWith('[]'))return Array.from({
    length:cursor.length()
  }, ()=>field(cursor, typ.slice(0, -2), schemas));
  if(typ==='System.Collections.Generic.List<uint>')return Array.from({
    length:cursor.length()
  }, ()=>field(cursor, 'uint', schemas));
  if(typ==='RPG.Client.TextID'){
    const v=cursor.varint();
    if(v>0xffffffff)fail('TextID hash overflow');
    return {
      hash:zigzag(v),
      hash64:cursor.varint()
    };
  }
  if(typ==='RPG.GameCore.FixPoint')return {
    wire:cursor.varint()
  };
  if(typ==='RPG.GameCore.AvatarPropertyValue'&&schemas)return record(cursor, schemas.AvatarPropertyValue, schemas);
  if(typ==='string'){
    const n=cursor.varint();
    if(n>16384||cursor.at+Number(n)>cursor.data.length)fail('invalid string');
    const raw=cursor.data.subarray(cursor.at, cursor.at+Number(n));
    cursor.at+=Number(n);
    return new TextDecoder('utf-8', {
      fatal:true
    }).decode(raw);
  }
  if(typ==='bool'){
    if(cursor.at>=cursor.data.length)fail('truncated bool');
    const v=cursor.data[cursor.at++];
    if(v>1)fail('invalid bool');
    return !!v;
  }
  if(typ==='uint'||ENUM_TYPES.has(typ)){
    const v=cursor.varint();
    if(v>0xffffffff)fail('uint overflow');
    return ENUM_TYPES.has(typ)?zigzag(v):v;
  }
  fail('unsupported type '+typ);
}
export function record(cursor, columns, schemas){
  const mask=BigInt(cursor.varint());
  if(!mask||mask>>BigInt(columns.length))fail('invalid presence mask');
  return Object.fromEntries(columns.flatMap((col, i)=>mask&(1n<<BigInt(i))?[[col.name, field(cursor, col.type, schemas)]]:[]));
}
export function encode_varint(value){
  let v=BigInt(value);
  if(v<0n||v>0xffffffffffffffffn)fail('varint overflow');
  const out=[];
  while(v>=128n){
    out.push(Number(v&127n)|128);
    v>>=7n;
  }
  out.push(Number(v));
  return Buffer.from(out);
}
export function encode_field(v, t, s){
  if(t.endsWith('[]'))return cat(encode_varint(2*v.length), v.map(x=>encode_field(x, t.slice(0, -2), s)));
  if(t==='System.Collections.Generic.List<uint>')return cat(encode_varint(2*v.length), v.map(encode_varint));
  if(t==='RPG.Client.TextID'){
    const h=BigInt(v.hash);
    return cat(encode_varint((h<<1n)^(h>>31n)), encode_varint(v.hash64));
  }
  if(t==='RPG.GameCore.FixPoint')return encode_varint(v.wire);
  if(t==='RPG.GameCore.AvatarPropertyValue'&&s)return encode_record(v, s.AvatarPropertyValue, s);
  if(ENUM_TYPES.has(t)){
    const x=BigInt(v);
    return encode_varint((x<<1n)^(x>>31n));
  }
  if(t==='bool')return Buffer.from([Number(v)]);
  if(t==='string'){
    const b=Buffer.from(v);
    return cat(encode_varint(b.length), b);
  }
  return encode_varint(v);
}
export function encode_record(row, cols, s){
  return cat(encode_varint(cols.reduce((m, col, i)=>col.name in row?m|(1n<<BigInt(i)):m, 0n)), cols.filter(col=>col.name in row).map(col=>encode_field(row[col.name], col.type, s)));
}
export const valid_roles=rows=>rows.length>=20&&c.uniqueValues(rows, r=>r.ID)&&rows.every(r=>r.ID>0&&r.ID<1000000&&r.AvatarID>=1000&&r.AvatarID<10000&&r.Rarity>=1&&r.Rarity<=5&&r.SeasonID>0&&r.SeasonID<100&&r.TraitList?.length&&r.TraitList.every(t=>t>0&&t<1000000));
export const valid_odds=rows=>rows.length>=5&&rows.length<=30&&rows.every((r, i)=>r.PlayerLevel===i+1&&[1, 2, 3, 4, 5].reduce((s, n)=>s+(r[`Rarity${n}Weight`]??0), 0)===100);
const tableProof=(name, blob, start, end, rows, data)=>({
  table:name,
  blob,
  offset:start,
  end,
  records:rows.length,
  rows,
  table_sha256:sha256(data.subarray(start, end)),
  blob_sha256:sha256(data)
});
const choose=(found, msg)=>{
  if(!found.length)fail(msg);
  if(new Set(found.map(m=>m.table_sha256)).size!==1)fail('ambiguous table; refusing to pick one');
  return found[0];
};
export function find_table(client, columns, name, anchor_blob=null){
  const roles=name==='GridFightRoleConfigRow';
  if(roles&&columns.slice(0, 4).map(c=>c.name).join(',')!=='ID,AvatarID,FrontBackType,Rarity')fail('role locator schema changed');
  if(!roles&&columns[0].name!=='PlayerLevel')fail('odds locator schema changed');
  for(const layer of ['Persistent', 'StreamingAssets']){
    const found=[];
    for(const p of c.globBytes(path.join(client, 'StarRail_Data', layer, 'DesignData/Windows'))){
      const blob=path.relative(path.join(client, 'StarRail_Data'), p);
      if(path.basename(p, '.bytes').length!==32||!fs.statSync(p).size||(anchor_blob&&anchor_blob!==blob))continue;
      const data=fs.readFileSync(p);
      if(roles&&data.indexOf('SpriteOutput/GridFight')<0)continue;
      for(let pos=0; pos<data.length; pos++){
        if(roles?!(data[pos]>=128&&(data[pos]&11)===11):!(data[pos]<=63&&(data[pos]&3)===3&&data[pos+1]===1))continue;
        try{
          if(roles){
            const prefix=new Cursor(data, pos),
            mask=BigInt(prefix.varint());
            if(mask>>BigInt(columns.length)||(mask&0x208bn)!==0x208bn)continue;
            const id=prefix.varint(),
            avatar=prefix.varint();
            if(mask&4n)prefix.varint();
            const rarity=prefix.varint();
            if(!(id>0&&id<1000000&&avatar>=1000&&avatar<10000&&rarity>=1&&rarity<=5))continue;
          }
          const first=record(new Cursor(data, pos), columns);
          if(roles?!(first.AvatarID>=1000&&first.AvatarID<10000&&first.Rarity>=1&&first.Rarity<=5&&first.TraitList?.length):first.PlayerLevel!==1)continue;
          for(let start=Math.max(0, pos-5); start<pos; start++){
            try{
              const cursor=new Cursor(data, start),
              count=cursor.length(roles?2000:30);
              if(cursor.at!==pos||count<(roles?20:5))continue;
              const rows=Array.from({
                length:count
              }, ()=>record(cursor, columns));
              if(!(roles?valid_roles:valid_odds)(rows))continue;
              const encoded=cat(encode_varint(count*2), rows.map(r=>encode_record(r, columns)));
              if(!data.subarray(start, cursor.at).equals(encoded))continue;
              found.push(tableProof(name, blob, start, cursor.at, rows, data));
            } catch(e){
              if(!(e instanceof c.DecodeError||e instanceof RangeError||e instanceof TypeError))throw e;
            }
          }
        } catch(e){
          if(!(e instanceof c.DecodeError||e instanceof RangeError||e instanceof TypeError))throw e;
        }
      }
    }
    if(found.length)return choose(found, name+': no verified complete table found');
  }
  fail(name+': no verified complete table found');
}
export function find_keyed_table(client, anchor, columns, name, first_key, valid, schemas, required_mask=null){
  const data=fs.readFileSync(path.join(client, 'StarRail_Data', anchor)),
  candidates=[];
  if(required_mask!==null){
    if(columns.length>10)fail('bounded locator requires at most ten fields');
    const prefixes=[];
    for(let m=1;
    m<2**columns.length;
    m++)if((m&required_mask)===required_mask)prefixes.push(cat(encode_varint(m), first_key===null?Buffer.alloc(0):encode_varint(first_key)));
    const groups=new Map();
    for(const p of prefixes){
      if(!groups.has(p[0]))groups.set(p[0], []);
      groups.get(p[0]).push(p);
    }
    for(let pos=0; pos<data.length; pos++){
      const group=groups.get(data[pos]);
      if(!group)continue;
      const p=group.find(p=>data.subarray(pos, pos+p.length).equals(p));
      if(p){
        candidates.push([pos, [pos]]);
        pos+=p.length-1;
      }
    }
  } else{
    const needle=encode_varint(first_key);
    for(let at=data.indexOf(needle);
    at>=0;
    at=data.indexOf(needle, at+needle.length))candidates.push([at, Array.from({
      length:Math.min(at, 10)
    }, (_, i)=>Math.max(0, at-10)+i)]);
  }
  const found=[];
  for(const [pos, starts]of candidates)for(const first of starts){
    try{
      const prefix=new Cursor(data, first),
      mask=BigInt(prefix.varint());
      if((required_mask===null&&prefix.at!==pos)||!(mask&1n)||mask>>BigInt(columns.length))continue;
      for(let start=Math.max(0, first-5); start<first; start++){
        try{
          if(!start||data[start-1]!==0)continue;
          const cursor=new Cursor(data, start),
          count=cursor.length(10000);
          if(cursor.at!==first||!count)continue;
          const rows=Array.from({
            length:count
          }, ()=>record(cursor, columns, schemas));
          if(!valid(rows))continue;
          const encoded=cat(encode_varint(count*2), rows.map(r=>encode_record(r, columns, schemas)));
          if(!data.subarray(start, cursor.at).equals(encoded))continue;
          found.push(tableProof(name, anchor, start, cursor.at, rows, data));
        } catch(e){
          if(!(e instanceof c.DecodeError||e instanceof RangeError||e instanceof TypeError))throw e;
        }
      }
    } catch(e){
      if(!(e instanceof c.DecodeError||e instanceof RangeError||e instanceof TypeError))throw e;
    }
  }
  return choose(found, name+': no complete related table found');
}
export function find_ui_blob(client){
  for(const layer of ['Persistent', 'StreamingAssets']){
    const found=c.globBytes(path.join(client, 'StarRail_Data', layer, 'DesignData/Windows')).filter(p=>{
      if(!fs.statSync(p).size)return false;
      const b=fs.readFileSync(p);
      return b[0]!==123&&b.includes(Buffer.from('GridFightEntrancePage'))&&b.includes(Buffer.from('SpriteOutput/Rogue/Tourn/Titan/RankIcon/Small/'));
    });
    if(found.length===1)return path.relative(path.join(client, 'StarRail_Data'), found[0]);
    if(found.length)fail('ambiguous GridFight UI Excel blob');
  }
  fail('no installed GridFight UI Excel blob');
}
export const valid_divisions=(rows, seasons)=>rows.length>=20&&c.uniqueValues(rows, r=>r.ID)&&c.subset(seasons, new Set(rows.map(r=>r.SeasonID)))&&rows.every(r=>r.ID>0&&r.ID<1000000&&seasons.has(r.SeasonID)&&(r.DivisionLevel??0)>=0&&(r.DivisionLevel??0)<=100&&r.Progress>0&&r.Progress<1000&&(!r.DivisionIcon||r.DivisionIcon.startsWith('SpriteOutput/Rogue/Tourn/Titan/RankIcon/')))&&rows.filter(r=>r.DivisionIcon).length>Math.floor(rows.length/2);
export const valid_season_modules=(rows, seasons)=>c.subset(seasons, new Set(rows.map(r=>r.SeasonID)))&&c.uniqueValues(rows, r=>[r.SeasonID, r.SubSeasonID].join(':'))&&rows.every(r=>seasons.has(r.SeasonID)&&r.SubSeasonID>0&&r.SubSeasonID<100&&r.ActivityModuleID>100000&&r.MaxRewardExp>0&&r.OfferingID>0);
const moduleList=r=>[...(r.ResidentModuleList??[]), ...(r.ActivityModuleIDList??[])];
export const valid_activities=(rows, modules)=>rows.length>=20&&c.uniqueValues(rows, r=>r.ActivityID)&&rows.every(r=>r.ActivityID>0&&r.ActivityID<10000000&&moduleList(r).every(m=>m>0))&&c.subset(modules, new Set(rows.flatMap(moduleList)));
export const valid_offering_levels=(rows, required)=>rows.length>20&&c.subset(required, new Set(rows.map(r=>r.TypeID)))&&c.uniqueValues(rows, r=>[r.TypeID, r.Level].join(':'))&&rows.every(r=>r.TypeID>0&&r.TypeID<10000&&r.Level>0&&r.Level<10000&&[0, 1].includes(r.Type??0)&&r.RewardID>0);
export const valid_offering_types=(rows, required, maxima)=>c.subset(required, new Set(rows.map(r=>r.ID)))&&c.uniqueValues(rows, r=>r.ID)&&rows.every(r=>r.ID>0&&r.ItemID>1000&&r.MaxLevel>0&&(!(r.ID in maxima)||r.MaxLevel===maxima[r.ID]));
export function season_contract(id, divisions, modules, activities){
  const selected=modules.filter(r=>r.SeasonID===id).sort((a, b)=>a.SubSeasonID-b.SubSeasonID);
  if(!selected.length)fail('requested season is absent');
  const module=selected[0],
  found=activities.filter(r=>moduleList(r).includes(module.ActivityModuleID));
  if(found.length!==1||!found[0].ActivityPanelID)fail('season module has no unique activity panel');
  const activity=found[0];
  return {
    season_id:id,
    divisions:divisions.filter(r=>r.SeasonID===id).map(r=>r.ID),
    activity_id:activity.ActivityID,
    panel_id:activity.ActivityPanelID,
    selection:'explicit season; first configured sub-season; not an inferred live schedule',
    raw:{
      selected_module:module,
      selected_activity:activity,
      divisions,
      season_modules:modules,
      activities:activities.filter(r=>modules.some(m=>moduleList(r).includes(m.ActivityModuleID)))
    }
  };
}
export const valid_trait_bases=(rows, required)=>c.subset(required, new Set(rows.map(r=>r.ID)))&&c.uniqueValues(rows, r=>r.ID)&&rows.every(r=>r.TraitName&&r.SeasonID>0&&(r.IconPath??'').startsWith('SpriteOutput/GridFight/'));
export const valid_trait_layers=(rows, required)=>c.subset(required, new Set(rows.map(r=>r.TraitID)))&&c.uniqueValues(rows, r=>[r.TraitID, r.Layer].join(':'))&&rows.every(r=>r.TraitID>0&&r.Layer>0&&r.Layer<100&&r.MazebuffID>=1000000);
export function text_matches(data, id){
  const needle=encode_field(id, 'RPG.Client.TextID'),
  found=[];
  for(let at=data.indexOf(needle); at>=0; at=data.indexOf(needle, at+needle.length)){
    if(!at||(data[at-1]&3)!==3||data[at-1]>=128)continue;
    try{
      const cursor=new Cursor(data, at+needle.length),
      text=field(cursor, 'string');
      if(text&&!/[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(text))found.push({
        offset:at-1,
        end:cursor.at,
        text
      });
    } catch(e){
      if(!(e instanceof c.DecodeError||e instanceof TypeError))throw e;
    }
  }
  if(new Set(found.map(f=>f.text)).size!==1)fail('TextMap key missing or conflicting');
  return found[0];
}
export function trait_names(client, rows, language){
  const keys=dict(rows.map(r=>[r.ID, r.TraitName]));
  for(const layer of ['Persistent', 'StreamingAssets']){
    const found=[];
    for(const p of c.globBytes(path.join(client, 'StarRail_Data', layer, 'DesignData/Windows', language))){
      if(!fs.statSync(p).size)continue;
      const data=fs.readFileSync(p);
      let resolved;
      try{
        resolved=dict(Object.keys(keys).map(k=>[k, text_matches(data, keys[k])]));
      } catch(e){
        if(e instanceof c.DecodeError)continue;
        throw e;
      }
      found.push([resolved, {
        blob:path.relative(path.join(client, 'StarRail_Data'), p),
        blob_sha256:sha256(data),
        keys:dict(Object.keys(keys).map(k=>[k, {
          text_id:keys[k],
          ...resolved[k]
        }]))
      }]);
    }
    if(found.length){
      if(new Set(found.map(m=>c.json(m[0]))).size!==1)fail('ambiguous TextMap blobs');
      return found[0];
    }
  }
  fail('no complete installed '+language+' TextMap for traits');
}
export function main(){
  const a=c.cli(['client', 'dump', 'output'], {
    language:'en',
    'evidence-dir':null,
    'season-id':null
  }, ['traits']);
  if(!['en', 'cn', 'cht', 'jp', 'kr', 'de', 'es', 'fr', 'id', 'pt', 'ru', 'th', 'vi'].includes(a.language))fail('Invalid language');
  const dump_bytes=fs.readFileSync(a.dump),
  dump=c.readText(a.dump),
  names=['GridFightRoleConfigRow', 'GridFightRarityWeightConfigRow'];
  if(a.traits)names.push('AvatarPropertyValue', 'GridFightTraitBaseConfigRow', 'GridFightTraitLayerConfigRow');
  if(a['season-id']!==null)names.push('GridFightDivisionConfigRow', 'GridFightSeasonModuleConfigRow', 'ActivityConfigRow', 'OfferingLevelConfigRow', 'OfferingTypeConfigRow');
  const schemas=Object.fromEntries(names.map(n=>[n, schema(dump, path.join(a.client, 'GameAssembly.dll'), n, a['evidence-dir']??path.join(a.output, 'evidence'))])),
  rt=find_table(a.client, schemas.GridFightRoleConfigRow, 'GridFightRoleConfigRow'),
  wt=find_table(a.client, schemas.GridFightRarityWeightConfigRow, 'GridFightRarityWeightConfigRow', rt.blob),
  tables={
    [rt.table]:rt,
    [wt.table]:wt
  };
  const roles=rt.rows.map(r=>({
    id:r.ID,
    cost:r.Rarity,
    avatar_id:r.AvatarID,
    traits:r.TraitList,
    raw:r
  })),
  odds=dict(wt.rows.map(r=>[r.PlayerLevel, [1, 2, 3, 4, 5].map(i=>r[`Rarity${i}Weight`]??0)])),
  outputs={
    'roles.json':roles,
    'shop_odds.json':odds
  };
  let text_evidence=null;
  if(a.traits){
    let required=new Set(roles.flatMap(r=>r.traits));
    const base=find_keyed_table(a.client, rt.blob, schemas.GridFightTraitBaseConfigRow, 'GridFightTraitBaseConfigRow', Math.min(...required), r=>valid_trait_bases(r, required), schemas);
    required=new Set(base.rows.map(r=>r.ID));
    const layers=find_keyed_table(a.client, rt.blob, schemas.GridFightTraitLayerConfigRow, 'GridFightTraitLayerConfigRow', Math.min(...required), r=>valid_trait_layers(r, required), schemas);
    const [resolved, proof]=trait_names(a.client, base.rows, a.language);
    text_evidence=proof;
    outputs['traits.json']=base.rows.map(r=>({
      id:r.ID,
      name:resolved[r.ID].text,
      thresholds:layers.rows.filter(t=>t.TraitID===r.ID).map(t=>t.Layer).sort((a, b)=>a-b),
      raw:{
        base:r,
        layers:layers.rows.filter(t=>t.TraitID===r.ID)
      }
    }));
    outputs['trait_layers.json']=layers.rows;
    tables[base.table]=base;
    tables[layers.table]=layers;
  }
  if(a['season-id']!==null){
    const seasons=new Set(roles.map(r=>r.raw.SeasonID)),
    ui=find_ui_blob(a.client),
    div=find_keyed_table(a.client, ui, schemas.GridFightDivisionConfigRow, 'GridFightDivisionConfigRow', 1, r=>valid_divisions(r, seasons), schemas, 0x163),
    modules=find_keyed_table(a.client, ui, schemas.GridFightSeasonModuleConfigRow, 'GridFightSeasonModuleConfigRow', Math.min(...seasons), r=>valid_season_modules(r, seasons), schemas, 0x1f),
    ids=new Set(modules.rows.map(r=>r.ActivityModuleID)),
    activities=find_keyed_table(a.client, ui, schemas.ActivityConfigRow, 'ActivityConfigRow', null, r=>valid_activities(r, ids), schemas, 0xd);
    outputs['season.json']=season_contract(Number(a['season-id']), div.rows, modules.rows, activities.rows);
    for(const t of [div, modules, activities])tables[t.table]=t;
    const offerings=new Set(modules.rows.map(r=>r.OfferingID)),
    levels=find_keyed_table(a.client, ui, schemas.OfferingLevelConfigRow, 'OfferingLevelConfigRow', 1, r=>valid_offering_levels(r, offerings), schemas, 3),
    normal=levels.rows,
    maxima={
    };
    for(const r of normal)if(!r.Type)maxima[r.TypeID]=Math.max(maxima[r.TypeID]??0, r.Level);
    const types=find_keyed_table(a.client, ui, schemas.OfferingTypeConfigRow, 'OfferingTypeConfigRow', 1, r=>valid_offering_types(r, offerings, maxima), schemas, 7),
    selected=outputs['season.json'].raw.selected_module.OfferingID;
    outputs['season.json'].raw.offering_type=types.rows.find(r=>r.ID===selected);
    outputs['season.json'].raw.offering_levels=normal.filter(r=>r.TypeID===selected);
    outputs['offering_levels.json']=normal;
    outputs['offering_types.json']=types.rows;
    tables[levels.table]=levels;
    tables[types.table]=types;
  }
  for(const [n, v]of Object.entries(outputs))atomic_json(path.join(a.output, n), v);
  atomic_json(path.join(a.output, 'schemas.json'), schemas);
  const manifest={
    schema:1,
    source:'installed-client-files',
    dump_sha256:sha256(dump_bytes),
    game_assembly_sha256:sha256_file(path.join(a.client, 'GameAssembly.dll')),
    outputs:Object.fromEntries(Object.keys(outputs).map(n=>[n, sha256_file(path.join(a.output, n))])),
    tables:Object.values(tables).map(t=>Object.fromEntries(Object.entries(t).filter(([k])=>k!=='rows'))),
    mapping:{
      'roles.cost':'GridFightRoleConfigRow.Rarity (shop tier; not a currency price)',
      'roles.raw.SeasonID':'Caller must select its active season; rows from multiple seasons are retained.',
      'shop_odds':'GridFightRarityWeightConfigRow.Rarity1Weight..Rarity5Weight; missing weights are zero.'
    }
  };
  if(text_evidence)manifest.trait_textmap=text_evidence;
  atomic_json(path.join(a.output, 'provenance.json'), manifest);
  console.log(`Validated ${roles.length} roles, ${Object.keys(odds).length} shop levels and ${Object.keys(tables).length} tables from installed client bytes.`);
}
c.runMain(import.meta.url, main);