xiaoshu-app/perf/speed-round3-2026-11-10/payroll-api-isolated.mjs

// Review first. Default only prepares private code; --run authorizes this fixed
// diagnostic execution. Nothing here publishes a gateway or writes business data.
import fs from 'node:fs';import assert from 'node:assert/strict';import {createHash,randomBytes} from 'node:crypto';
import {patchFunctions,localCandidates,OPERATIONS_HELPERS} from '../../scripts/speed-round3-patch.mjs';
const read=p=>fs.readFileSync(p,'utf8'),hash=s=>createHash('sha256').update(s).digest('hex');
const privateDir='tmp/speed-round3-2026-11-10',outDir='perf/speed-round3-2026-11-10',savedDir='/Users/mac/.local/state/xiaoshu/cloud-releases/2026-11-10-speed-round3';
const args=process.argv.slice(2),execute=args.includes('--run'),smoke=args.includes('--smoke'),monthArg=args.find(a=>a.startsWith('--month=')),month=monthArg?.slice(8)||'2026-11';
if(args.some(a=>!['--run','--smoke'].includes(a)&&a!==monthArg)||!/^\d{4}-(0[1-9]|1[0-2])$/.test(month))throw Error('Usage: node --import ./tmp/admin-speed-round2-2026-11-10/env.mjs perf/speed-round3-2026-11-10/payroll-api-isolated.mjs [--run] [--smoke] [--month=YYYY-MM]');
const baseline=JSON.parse(read(savedDir+'/admin-gateway.json')),patched=patchFunctions(baseline.code,localCandidates().operations,OPERATIONS_HELPERS),definitions=JSON.parse(read(savedDir+'/original-definitions.json'));
assert.equal(definitions.length,39,'Expected the reviewed 39 baseline PostgreSQL definitions');
const schema='speed3_api_'+randomBytes(6).toString('hex'),company='7pIbDBJmKx';
const rewrite=s=>s.replace(/^BEGIN;\s*$/m,'').replace(/^COMMIT;\s*$/m,'').replaceAll('public.',schema+'.').replace(/(\bnspname\s*=\s*)'public'/g,"$1'"+schema+"'").replaceAll('xs-payroll-source-cache:','isolated-'+schema+'-source:').replaceAll('xs-payroll-version-cache:','isolated-'+schema+'-version:');
const tenantTables=['CommonModel','CourseAppointment','LessonRecord','LessonRecordFact','MemoryPracticeRecord','TeachingCompensationRule','CourseTeachingProfile','CoachPayRate','ReviewReward','ReviewRewardCorrection','TeachingCourseCategory','LegacyDirectRun','LegacyDirectEvidence','LegacySyncConflict','PayrollCutoffDecision','PayrollCutoffApproval','PayrollReadDigest','PayrollLine','PayrollBatch','_User','Node','CourseBinding'];
const globalTables=['PayrollReadDigestMeta','PayrollReadAuthority'],emptyTables=['PayrollVerifiedReadCache','PayrollReadChange','PayrollReadChangeScope','PayrollCommand','CourseCreditReservation','UserUserPoint','PayrollReconciliation'];
const sql={functions:definitions.map(row=>rewrite(row.definition)).join(';\n'),bulk:rewrite(read('scripts/sql/payroll-source-bulk.sql')),index:rewrite(read('scripts/sql/payroll-source-index.sql')),snapshot:rewrite(read('scripts/sql/payroll-read-snapshot.sql')),conflict:rewrite(read('scripts/sql/payroll-cutoff-bulk.sql'))};
// No public fallback: an omitted table/function must fail, never silently read or
// write public data. Public relations occur only in the fixed setup copy statements.
const config={schema,company,month,tenantTables,globalTables,emptyTables,sql,operatorId:'__OPERATOR_BOUND_AT_RUN__'};
function runtimeSupport(){
 let activeVariant='',inFlight=new Set(),queries=[],policyRows=new Map(),unexpectedPolicies=new Set();
 const quote=name=>'"'+name.replaceAll('"','""')+'"';
 const settings=async tx=>{await tx.none('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ');await tx.none('SET LOCAL search_path='+quote(config.schema)+',pg_catalog');await tx.none("SET LOCAL statement_timeout='120s'; SET LOCAL jit=off");};
 const track=promise=>{inFlight.add(promise);promise.then(()=>inFlight.delete(promise),()=>inFlight.delete(promise));return promise;};
 const dbProxy=(db,inTransaction=false)=>new Proxy({},{get(_target,name){
  if(name==='tx')return callback=>track(db.tx(async tx=>{await settings(tx);return callback(dbProxy(tx,true));}));
  if(!['query','one','oneOrNone','any','many','none'].includes(name))throw Error('Unexpected diagnostic DB method '+String(name));
  return(sql,args)=>{
   if(/\bpublic\s*\./i.test(sql)||/\bsearch_path\b/i.test(sql))throw Error('Gateway attempted to escape isolated schema');
   if(/^SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY$/i.test(sql)){if(!inTransaction)throw Error('Missing explicit read snapshot');return db.none(sql);}
   if(!/^\s*(SELECT|WITH)\b/i.test(sql))throw Error('Non-read gateway SQL rejected');
   const started=Date.now();
   const job=inTransaction?db[name](sql,args):db.tx(async tx=>{await settings(tx);return tx[name](sql,args);});
   return track(job.then(value=>{if(sql.includes('xs_payroll_read_snapshot')&&!value?.result)throw Error('Coherent snapshot unexpectedly fell back');queries.push({method:name,ms:Date.now()-started,kind:sql.includes('xs_payroll_read_snapshot')?'coherent-snapshot':sql.includes('xs_payroll_sources_cached')?'sources-cold':sql.includes('xs_payroll_cutoff_snapshot_fast')?'cutoff-cold':sql.includes('xs_payroll_preview_cache')?'preview-cache':sql.includes('xs_payroll_read_users')?'thin-users':'other',rows:Array.isArray(value)?value.length:1});return value;}));
  };
 }});
 const isolatedDb=dbProxy(Psql);
 const sharedPolicies=async(original,className,context,input,limit=1000)=>{const key=className+':'+limit;if(!policyRows.has(key)){unexpectedPolicies.add(key);policyRows.set(key,await original(className,context,input,limit));}return policyRows.get(key);};
 const context=()=>({roles:['ops-manager'],company:{id:config.company},current:{id:config.operatorId},isSuperAdmin:false});
 async function setup(){return Psql.tx(async tx=>{
  await tx.none('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ');await tx.none('CREATE SCHEMA '+quote(config.schema));await tx.none('REVOKE ALL ON SCHEMA '+quote(config.schema)+' FROM PUBLIC');await tx.none('SET LOCAL search_path='+quote(config.schema)+',pg_catalog');await tx.none("SET LOCAL statement_timeout='120s'; SET LOCAL jit=off");
  for(const table of config.tenantTables)await tx.none('CREATE TABLE '+quote(table)+' AS SELECT * FROM public.'+quote(table)+' WHERE company=$1'+(table==='CommonModel'?' AND "modelId" IN (54,59,60)':''),[config.company]);
  for(const table of config.globalTables)await tx.none('CREATE TABLE '+quote(table)+' AS SELECT * FROM public.'+quote(table));
  for(const table of config.emptyTables)await tx.none('CREATE TABLE '+quote(table)+' (LIKE public.'+quote(table)+' INCLUDING ALL)');
  await tx.none('CREATE TABLE "Function" AS SELECT * FROM public."Function" WHERE path=\'xiaoshu/ops/gateway-v3\'');
  // Keep pg_get_viewdef meaningful to baseline stamps while freezing exact rows.
  await tx.none('CREATE TABLE "ReviewRewardIncomeSnapshot" AS SELECT * FROM public."ReviewRewardIncome" WHERE company=$1',[config.company]);await tx.none('CREATE VIEW "ReviewRewardIncome" AS SELECT * FROM "ReviewRewardIncomeSnapshot"');
  for(const table of ['CommonModel','CourseAppointment','LessonRecord','LessonRecordFact','MemoryPracticeRecord','TeachingCompensationRule','CoachPayRate','LegacySyncConflict','_User','Node','CourseBinding','PayrollLine','PayrollBatch'])await tx.none('CREATE UNIQUE INDEX ON '+quote(table)+' ("objectId")');
  // Teacher mappings SELECT p.* GROUP BY p.objectId: PostgreSQL recognizes the
  // functional dependency only for a primary key, not a standalone unique index.
  await tx.none('ALTER TABLE "CourseTeachingProfile" ADD PRIMARY KEY ("objectId")');
  await tx.none('CREATE UNIQUE INDEX ON "PayrollReadAuthority" (name); CREATE UNIQUE INDEX ON "PayrollReadDigestMeta" (kind); CREATE UNIQUE INDEX ON "PayrollReadDigest" (kind,company,"objectId"); CREATE INDEX ON "PayrollReadDigest" (company,kind COLLATE "C",hash COLLATE "C")');
  for(const table of ['CourseAppointment','LessonRecord','MemoryPracticeRecord'])await tx.none('CREATE INDEX ON '+quote(table)+' (company,id)');
  await tx.none('CREATE INDEX ON "CommonModel" (company,"modelId","itemId","objectId"); CREATE INDEX ON "CommonModel" (company,"modelId",("generalId"::text)); CREATE INDEX ON "CommonModel" (company,"modelId","generalId")');
  // Saved definitions are alphabetical, not dependency sorted. Defer body lookup
  // until all definitions exist; copied command rowtypes are present but unused.
  await tx.none('SET LOCAL check_function_bodies=off');await tx.none(config.sql.functions);await tx.none('SET LOCAL check_function_bodies=on');
  // Static copied digest only. This diagnostic DOES NOT validate source writes,
  // digest triggers, or their concurrency; no copied business source is mutated.
  await tx.none('CREATE OR REPLACE FUNCTION xs_payroll_digest_ready() RETURNS boolean LANGUAGE sql STABLE AS $$ SELECT true $$');
  await tx.none('UPDATE "PayrollReadAuthority" SET hash=md5(pg_get_functiondef(to_regprocedure(name)))');
  await tx.any(config.sql.bulk);await tx.any(config.sql.index);await tx.any(config.sql.snapshot);await tx.any(config.sql.conflict);
  for(const table of [...config.tenantTables,...config.globalTables,...config.emptyTables,'ReviewRewardIncomeSnapshot','PayrollSourceIndex','PayrollSourceIndexMeta'])await tx.none('ANALYZE '+quote(table));
  const guards=await tx.one('SELECT xs_payroll_authority_ready() authority,xs_payroll_digest_ready() digest,xs_payroll_source_index_ready() source_index,xs_payroll_read_snapshot_authority_ready() snapshot');
  if(Object.values(guards).some(value=>value!==true))throw Error('Clone readiness check failed');
  return {guards,copiedTables:config.tenantTables.length+config.globalTables.length+config.emptyTables.length+2,staticDigestOnly:true};
 });}
 async function clearCache(){await Promise.allSettled([...inFlight]);return Psql.tx(async tx=>{await settings(tx);await tx.none('TRUNCATE "PayrollVerifiedReadCache"');const row=await tx.one('SELECT count(*)::int n FROM "PayrollVerifiedReadCache"');if(row.n!==0)throw Error('Cache not cold');return row.n;});}
 async function run(input){
  if(input.action==='setup')return setup();
  if(input.action==='drop'){await Promise.allSettled([...inFlight]);await Psql.none('DROP SCHEMA IF EXISTS '+quote(config.schema)+' CASCADE');return {dropped:true};}
  if(input.action!=='pair'||!['AB','BA'].includes(input.order))throw Error('Unknown fixed diagnostic action');
  policyRows=new Map();unexpectedPolicies=new Set();const ctx=context(),params={month:config.month,summaryOnly:false,displayOnly:false};
  // Use identical actual Parse objects for both variants, outside both timers.
  for(const [name,limit] of [['TeachingCourseCategory',1000],['CourseTeachingProfile',2000]])policyRows.set(name+':'+limit,await baselineApi.originalPolicies(name,ctx,params,limit));
  const results=[];
  for(const variant of input.order==='AB'?['baseline','candidate']:['candidate','baseline']){
   const coldBefore=await clearCache();activeVariant=variant;queries=[];const at=Date.now();
   try{
    const output=await (variant==='baseline'?baselineApi:candidateApi).overview(ctx,params),serviceMs=Date.now()-at;
    if(output.sourceStatus?.cacheHit!==false)throw Error('Expected explicitly cold result');
    if(output.sourceStatus?.sync?.state==='error')throw Error('Cutoff query failed; timings are invalid');
    if(variant==='candidate'&&!queries.some(q=>q.kind==='coherent-snapshot'))throw Error('Candidate did not exercise coherent snapshot');
    results.push({variant,serviceMs,queries:[...queries],coldBefore,output});
   }finally{await clearCache();}
  }
  if(unexpectedPolicies.size)throw Error('Unprefetched Parse policy reads: '+[...unexpectedPolicies].join(','));
  return {results,coldAfter:0};
 }
 return {isolatedDb,sharedPolicies,run};
}
function factory(code){return `(()=>{${code.replace(/\bPsql\b/g,'runtime.isolatedDb')}\nconst originalPolicies=newClassObjects;newClassObjects=(...args)=>runtime.sharedPolicies(originalPolicies,...args);return{overview:payrollOverviewData,originalPolicies};})()`;}
function sourceFor(operatorId){return 'const config='+JSON.stringify({...config,operatorId})+';\nconst runtime=('+runtimeSupport.toString()+')();\nconst baselineApi='+factory(baseline.code)+';\nconst candidateApi='+factory(patched.code)+';\nasync function run(input){return runtime.run(input);}';}
const normalize=value=>Array.isArray(value)?value.map(normalize):value&&typeof value==='object'?Object.fromEntries(Object.keys(value).sort().filter(key=>!['refreshedAt','lagSeconds','cacheHit'].includes(key)).map(key=>[key,normalize(value[key])])):value;
const reportContext='Cold round-2 production admin gateway baseline versus selective round-3 candidate on one static real-data clone. Ten sequential pairs alternate AB/BA. Each SQL operation uses clone-only search_path and RR; explicit candidate transactions preserve their single-snapshot semantics. TeachingCourseCategory and CourseTeachingProfile Parse reads/schema lookups are prefetched and shared within each pair OUTSIDE service timers. Service time also excludes setup, cache clearing, authentication and transport; pairRequestMs includes those per-pair prefetches/clears and transport for BOTH variants. This is not full API user-experience timing. ReviewRewardIncome is frozen as an equivalent copied-row view. All clone result caches are emptied before and after every variant. Digest readiness is stubbed for an unchanged copied digest: no source-write/trigger acceptance is claimed. Operator-bound manager projection, not manager-login acceptance.';
fs.mkdirSync(privateDir,{recursive:true,mode:0o700});new Function(sourceFor(config.operatorId));
fs.writeFileSync(privateDir+'/payroll-api-isolated-prepared.js',sourceFor(config.operatorId),{mode:0o600});fs.writeFileSync(privateDir+'/payroll-api-isolated-patch-audit.json',JSON.stringify(patched.audit,null,2),{mode:0o600});
if(!execute){console.log(JSON.stringify({prepared:true,willRun:false,rounds:smoke?1:10,month,script:privateDir+'/payroll-api-isolated-prepared.js',baselineHash:hash(baseline.code),candidateHash:hash(patched.code),reviewNote:'Run only after reviewing clone setup and baseline fidelity.'}));}
else{
 const {withGateway,operator,parse}=await import('./server-util.mjs'),me=await operator();
 const live=await parse('/classes/Function/'+baseline.objectId);assert.equal(hash(live.code),hash(baseline.code),'Production gateway drifted; refresh reviewed baseline before running');
 const samples=[],rounds=smoke?1:10;let setupResult,removed=false;
 await withGateway(sourceFor(me.objectId),async call=>{try{
  setupResult=await call({action:'setup'});
  for(let round=0;round<rounds;round++){
   const order=round%2?'BA':'AB',started=performance.now(),pair=await call({action:'pair',order}),requestMs=Math.round(performance.now()-started);
   assert.equal(pair.coldAfter,0);const [a,b]=pair.results;assert.deepEqual(normalize(a.output),normalize(b.output),'Full overview output changed in round '+round);
   for(const row of pair.results){fs.writeFileSync(privateDir+'/payroll-api-isolated-'+round+'-'+row.variant+'.json',JSON.stringify(row),{mode:0o600});const sample={round,order,variant:row.variant,serviceMs:row.serviceMs,pairRequestMs:requestMs,outputHash:hash(JSON.stringify(normalize(row.output))),coldBefore:row.coldBefore,cacheHit:row.output.sourceStatus.cacheHit,queries:row.queries};samples.push(sample);console.log(JSON.stringify({round,order,variant:sample.variant,serviceMs:sample.serviceMs,outputHash:sample.outputHash,cacheHit:sample.cacheHit}));}
  }
 }finally{removed=(await call({action:'drop'})).dropped===true;}});
 const percentile=(values,p)=>values.toSorted((a,b)=>a-b)[Math.ceil(values.length*p)-1],summary=Object.fromEntries(['baseline','candidate'].map(variant=>{const rows=samples.filter(row=>row.variant===variant);return[variant,{samples:rows.length,p50Ms:percentile(rows.map(r=>r.serviceMs),.5),p75Ms:percentile(rows.map(r=>r.serviceMs),.75),p95Ms:percentile(rows.map(r=>r.serviceMs),.95)}];}));
 fs.writeFileSync(outDir+'/payroll-api-isolated'+(smoke?'-smoke':'')+'.json',JSON.stringify({context:reportContext,month,baselineHash:hash(baseline.code),candidateHash:hash(patched.code),setup:setupResult,removed,fullOutputEquality:true,normalization:['refreshedAt','lagSeconds','cacheHit'],summary,samples},null,2));console.log(JSON.stringify({summary,removed,fullOutputEquality:true}));
}