mbx/mb-project-info.git

import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import crypto from 'node:crypto';
import {pathToFileURL} from 'node:url';
import * as base from './detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_20260730.mjs';
import {parseAuthorityCsv,serializeCsv,serializeManifestDataRows,validateAppendStableManifest} from './artifact_manifest_append_stable_parser_repair001_20260730.mjs';
 
export * from './detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_20260730.mjs';
export const DESIGN_ID='DESIGN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-REPAIR-001';
export const RELEASE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-DESIGN-REPAIR001-REREVIEW-001';
export const SCRIPT='dev/ana-dev/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_repair001_20260730.mjs';
export const CONTRACT=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_contract_repair001_20260730.csv`;
export const SCHEMA=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_schema_repair001_20260730.csv`;
export const EXEC_SET=`${base.BASE}/manifest/detail_strengthening_p0_eligible6_formal_evidence_integration_execution_artifact_set_repair001_20260730.csv`;
export const FORMAL_ENTRY_AUTHORITY=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_formal_design_entry_authority_repair001_20260730.csv`;
export const TRANSACTION_FAULT_COLUMNS=['test_id','failure_stage','actual_io_throw','expected_result','actual_result','exact_error_class','map_restored','manifest_restored','generated_absent','safe_state_verified','result'];
 
const ROOT=base.ROOT,abs=value=>path.join(ROOT,...value.split('/'));
const hash=value=>crypto.createHash('sha256').update(value).digest('hex');
const normalize=value=>value.toString('utf8').replace(/^\uFEFF/,'').replace(/\r\n/g,'\n').replace(/\r/g,'\n');
const lineCount=value=>{const text=normalize(value);return text.split('\n').length-(text.endsWith('\n')?1:0);};
const readCsv=file=>{const parsed=parseAuthorityCsv(normalize(fs.readFileSync(abs(file))));if(parsed.errors.length)throw new Error(`CSV:${file}:${parsed.errors.join('|')}`);return parsed;};
const identity=file=>{const buffer=fs.readFileSync(abs(file)),stat=fs.statSync(abs(file));return{rows:file.endsWith('.csv')?readCsv(file).rows.length:lineCount(buffer),bytes:buffer.length,sha256:hash(buffer),mtime:new Date(Math.trunc(stat.mtimeMs)).toISOString(),mtimeMs:Math.trunc(stat.mtimeMs)};};
const exactColumns=(parsed,columns,code)=>parsed.header.join('|')===columns.join('|')?[]:[`${code}_COLUMNS`];
const compareRows=(actual,expected,columns,code)=>{const errors=[];if(actual.length!==expected.length)return[`${code}_COUNT:${actual.length}:${expected.length}`];for(let i=0;i<expected.length;i++)for(const column of columns)if(String(actual[i]?.[column]??'')!==String(expected[i]?.[column]??'')){errors.push(`${code}_FIELD:${i+1}:${column}`);break;}return errors;};
const canonicalLine=line=>{let value=line.trim().replace(/^[\-*]\s*/,'').trim();if(value.startsWith('`')&&value.endsWith('`'))value=value.slice(1,-1);return value.trim();};
const write=(file,text)=>{fs.mkdirSync(path.dirname(abs(file)),{recursive:true});fs.writeFileSync(abs(file),text,'utf8');};
 
export function contractRowsR1(){const extras=[['TRANSACTION_ENTRY','generation through manifest final validation uses runFailClosedTransactionR1'],['MANIFEST_SEVEN_FIELD_FAULT','wrong case/run/batch/path/hash/bytes/mtime candidate rejected before commit'],['MANIFEST_WRITE_FAULT','actual manifest write throw enters production rollback'],['POSTWRITE_FAULT','actual final oracle failure enters production rollback'],['RESTORE_WRITE_FALLBACK','actual primary restore write throw uses open/write fallback and is surfaced'],['RESTORE_MTIME_FALLBACK','actual primary utimes throw uses futimes fallback and is surfaced'],['REMOVE_FALLBACK','actual primary rm throw uses unlink fallback and is surfaced'],['POSTCHECK_READ_FAIL','read exception caught and classified ROLLBACK_INCOMPLETE_HELD'],['POSTCHECK_STAT_FAIL','stat exception caught and classified ROLLBACK_INCOMPLETE_HELD']];return[...base.contractRows(),...extras.map((row,index)=>({contract_id:`P0INTR1-CON-${String(index+1).padStart(3,'0')}`,scope:'TRANSACTION_REAL_IO_FAIL_CLOSED',field_or_gate:row[0],required_value_or_rule:row[1],failure_state:'ROLLBACK_INCOMPLETE_HELD'}))];}
export function schemaRowsR1(){return base.schemaRows().map(row=>row.artifact_role==='EXECUTION_VALIDATION'?{...row,row_count_rule:'23'}:row);}
export function executionSetRowsR1(){return base.executionSetRows().map(row=>row.generation_order==='1'?{...row,artifact_path:SCRIPT}:row.generation_order==='14'?{...row,artifact_path:CONTRACT}:row.generation_order==='15'?{...row,artifact_path:SCHEMA}:row.generation_order==='16'?{...row,artifact_path:EXEC_SET}:row);}
 
export function releaseTextErrorsR1(text){const lines=text.split('\n').map(canonicalLine),required=['result=PASS','execution_release=EXPLICITLY_RELEASED',`released_batch_id=${base.EXEC_BATCH}`,`released_run_id=${base.EXEC_RUN}`,'network_scope=FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK','integration_ceiling=FORMAL_REFERENCE_REGISTRATION_ONLY_GAPS_REMAIN_OPEN_NO_UPGRADE','map_effect=APPEND_ONE_REGISTER_ROW_EMAP_046_ONLY'],errors=[];for(const marker of required)if(lines.filter(line=>line===marker).length!==1)errors.push(`RELEASE_MARKER_COUNT:${marker}`);if(lines.some(line=>/^(?:result|conclusion|review_result)=FAIL(?:_|$)/.test(line))||lines.some(line=>/^(?:execution_release|.*_release)=(?:NOT_ALLOWED|NOT_RELEASED)(?:_|$)/.test(line)))errors.push('RELEASE_CONTRADICTION');return errors;}
function releaseErrorsR1({required=false}={}){const entry=base.auditEntry(RELEASE_AUDIT);return entry?releaseTextErrorsR1(entry.text):required?['RELEASE_AUDIT_MISSING']:[];}
function formalEntryErrorsR1(){if(!fs.existsSync(abs(FORMAL_ENTRY_AUTHORITY)))return['FORMAL_ENTRY_AUTHORITY_MISSING'];const parsed=readCsv(FORMAL_ENTRY_AUTHORITY),errors=[...exactColumns(parsed,base.FORMAL_ENTRY_COLUMNS,'FORMAL_ENTRY')];if(parsed.rows.length!==1)return[...errors,`FORMAL_ENTRY_COUNT:${parsed.rows.length}`];const row=parsed.rows[0],lines=normalize(fs.readFileSync(abs(row.artifact_path))).split('\n'),buffer=Buffer.from(`${lines.slice(Number(row.start_line)-1,Number(row.end_line)).join('\n')}\n`);if(String(lineCount(buffer))!==row.lines||String(buffer.length)!==row.bytes||hash(buffer)!==row.sha256)errors.push('FORMAL_ENTRY_IDENTITY');for(const marker of row.required_markers.split('|'))if(!buffer.toString('utf8').includes(marker))errors.push(`FORMAL_ENTRY_MARKER:${marker}`);return errors;}
 
function fallbackWrite(file,buffer,errors){let fd;try{fd=fs.openSync(file,'w');let offset=0;while(offset<buffer.length)offset+=fs.writeSync(fd,buffer,offset,buffer.length-offset,offset);}catch(error){errors.push(`FALLBACK_RESTORE_WRITE:${file}:${error.message}`);}finally{if(fd!==undefined)try{fs.closeSync(fd);}catch(error){errors.push(`FALLBACK_CLOSE:${file}:${error.message}`);}}}
function fallbackMtime(file,stat,errors){let fd;try{fd=fs.openSync(file,'r+');fs.futimesSync(fd,stat.atime,stat.mtime);}catch(error){errors.push(`FALLBACK_RESTORE_MTIME:${file}:${error.message}`);}finally{if(fd!==undefined)try{fs.closeSync(fd);}catch(error){errors.push(`FALLBACK_MTIME_CLOSE:${file}:${error.message}`);}}}
function fallbackRemove(file,errors){try{fs.unlinkSync(file);}catch(error){if(error.code!=='ENOENT')errors.push(`FALLBACK_REMOVE:${file}:${error.message}`);}}
export function rollbackAndVerifyR1({snapshots,removePaths,primary=fs,checker=fs}){const errors=[];for(const item of snapshots){try{primary.writeFileSync(item.file,item.buffer);}catch(error){errors.push(`PRIMARY_RESTORE_WRITE:${item.file}:${error.message}`);fallbackWrite(item.file,item.buffer,errors);}try{primary.utimesSync(item.file,item.stat.atime,item.stat.mtime);}catch(error){errors.push(`PRIMARY_RESTORE_MTIME:${item.file}:${error.message}`);fallbackMtime(item.file,item.stat,errors);}}for(const file of removePaths)if(fs.existsSync(file))try{primary.rmSync(file);}catch(error){errors.push(`PRIMARY_REMOVE:${file}:${error.message}`);fallbackRemove(file,errors);}for(const item of snapshots){try{const current=checker.readFileSync(item.file);if(!current.equals(item.buffer))errors.push(`POSTCHECK_BYTES:${item.file}`);}catch(error){errors.push(`POSTCHECK_READ:${item.file}:${error.message}`);}try{const stat=checker.statSync(item.file);if(Math.trunc(stat.mtimeMs)!==Math.trunc(item.stat.mtimeMs))errors.push(`POSTCHECK_MTIME:${item.file}`);}catch(error){errors.push(`POSTCHECK_STAT:${item.file}:${error.message}`);}}for(const file of removePaths)try{if(checker.existsSync(file))errors.push(`POSTCHECK_GENERATED_PRESENT:${file}`);}catch(error){errors.push(`POSTCHECK_EXISTS:${file}:${error.message}`);}return{errors,safe:errors.filter(code=>code.startsWith('POSTCHECK_')||code.startsWith('FALLBACK_')).length===0};}
export function runFailClosedTransactionR1({snapshots,removePaths,work,rollbackPrimary=fs,rollbackChecker=fs}){try{return work();}catch(error){const rollback=rollbackAndVerifyR1({snapshots,removePaths,primary:rollbackPrimary,checker:rollbackChecker});if(rollback.errors.length)throw new Error(`ROLLBACK_INCOMPLETE_HELD:${rollback.errors.join('|')}:${error.message}`);throw error;}}
 
function faultCase(name,{workFactory,rollbackPrimaryFactory,rollbackCheckerFactory,expectHeld=false,expectIo=false}){const dir=fs.mkdtempSync(path.join(os.tmpdir(),'p0int-r1-')),map=path.join(dir,'map.csv'),manifest=path.join(dir,'manifest.csv'),generated=path.join(dir,'generated.csv'),mapBefore=Buffer.from('map-before\n'),manifestBefore=Buffer.from('manifest-before\n'),fixedTime=new Date('2026-07-30T00:00:00.000Z');fs.writeFileSync(map,mapBefore);fs.writeFileSync(manifest,manifestBefore);fs.utimesSync(map,fixedTime,fixedTime);fs.utimesSync(manifest,fixedTime,fixedTime);const mapStat=fs.statSync(map),manifestStat=fs.statSync(manifest),snapshots=[{file:map,buffer:mapBefore,stat:mapStat},{file:manifest,buffer:manifestBefore,stat:manifestStat}],flags={io:false};let message='NONE';try{runFailClosedTransactionR1({snapshots,removePaths:[generated],rollbackPrimary:rollbackPrimaryFactory?.({map,manifest,generated,flags})??fs,rollbackChecker:rollbackCheckerFactory?.({map,manifest,generated,flags})??fs,work:()=>workFactory({map,manifest,generated,flags})});message='UNEXPECTED_SUCCESS';}catch(error){message=error.message;}let mapOk=false,manifestOk=false,absent=false;try{mapOk=fs.readFileSync(map).equals(mapBefore)&&Math.trunc(fs.statSync(map).mtimeMs)===Math.trunc(mapStat.mtimeMs);manifestOk=fs.readFileSync(manifest).equals(manifestBefore)&&Math.trunc(fs.statSync(manifest).mtimeMs)===Math.trunc(manifestStat.mtimeMs);absent=!fs.existsSync(generated);}finally{fs.rmSync(dir,{recursive:true,force:true});}const actual=message.startsWith('ROLLBACK_INCOMPLETE_HELD:')?'ROLLBACK_INCOMPLETE_HELD':message==='UNEXPECTED_SUCCESS'?'UNEXPECTED_SUCCESS':'SAFE_ABORT',expected=expectHeld?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT',pass=actual===expected&&flags.io===expectIo&&mapOk&&manifestOk&&absent;return{test_id:`P0INTR1-IO-${name}`,failure_stage:name,actual_io_throw:flags.io?'YES':'NO',expected_result:expected,actual_result:actual,exact_error_class:message.split(':')[0],map_restored:mapOk?'YES':'NO',manifest_restored:manifestOk?'YES':'NO',generated_absent:absent?'YES':'NO',safe_state_verified:mapOk&&manifestOk&&absent?'YES':'NO',result:pass?'PASS':'FAIL',debug_message:message};}
function proxyWith(overrides){return new Proxy(fs,{get(target,prop){return overrides[prop]??target[prop];}});}
export function transactionFaultRows(){const cases=[];cases.push(faultCase('CLEAN_ROLLBACK_CONTROL',{workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('CONTROLLED_ABORT');}}));cases.push(faultCase('MANIFEST_SEVEN_FIELD_CANDIDATE',{workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(generated,'x');const header='"case_id","run_id","batch_id","artifact_path","sha256","bytes","mtime"\n',correct={case_id:'C',run_id:'R',batch_id:'B',artifact_path:'x',sha256:'0'.repeat(64),bytes:'1',mtime:'2026-07-30T00:00:00.000Z'},wrong={...correct,case_id:'WRONG'},candidate=Buffer.from(header+serializeManifestDataRows([wrong])),state=validateAppendStableManifest(candidate,{anomalyRows:[],originalRunId:'NONE',originalRunExpectedRows:0,expectedRunRows:[correct],expectedRunId:'R',expectedPhysicalDelta:1});if(!state.errors.length)throw new Error('FAULT_NOT_APPLIED');fs.writeFileSync(manifest,'changed');throw new Error(`MANIFEST_CANDIDATE_SEVEN_FIELD:${state.errors[0]}`);}}));cases.push(faultCase('MANIFEST_WRITE_FAILURE',{expectIo:true,workFactory:({map,manifest,generated,flags})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(generated,'x');flags.io=true;throw new Error('INJECTED_MANIFEST_WRITE_FAILURE');}}));cases.push(faultCase('POSTWRITE_FAILURE',{workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('INJECTED_POSTWRITE_FAILURE');}}));cases.push(faultCase('RESTORE_WRITE_FAILURE',{expectHeld:true,expectIo:true,workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('TRIGGER_ROLLBACK');},rollbackPrimaryFactory:({map,flags})=>{let once=true;return proxyWith({writeFileSync:(file,...args)=>{if(file===map&&once){once=false;flags.io=true;throw new Error('INJECTED_RESTORE_WRITE_THROW');}return fs.writeFileSync(file,...args);}});}}));cases.push(faultCase('RESTORE_MTIME_FAILURE',{expectHeld:true,expectIo:true,workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('TRIGGER_ROLLBACK');},rollbackPrimaryFactory:({map,flags})=>{let once=true;return proxyWith({utimesSync:(file,...args)=>{if(file===map&&once){once=false;flags.io=true;throw new Error('INJECTED_RESTORE_MTIME_THROW');}return fs.utimesSync(file,...args);}});}}));cases.push(faultCase('REMOVE_FAILURE',{expectHeld:true,expectIo:true,workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('TRIGGER_ROLLBACK');},rollbackPrimaryFactory:({generated,flags})=>{let once=true;return proxyWith({rmSync:(file,...args)=>{if(file===generated&&once){once=false;flags.io=true;throw new Error('INJECTED_REMOVE_THROW');}return fs.rmSync(file,...args);}});}}));cases.push(faultCase('POSTCHECK_READ_FAILURE',{expectHeld:true,expectIo:true,workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('TRIGGER_ROLLBACK');},rollbackCheckerFactory:({map,flags})=>{let once=true;return proxyWith({readFileSync:(file,...args)=>{if(file===map&&once){once=false;flags.io=true;throw new Error('INJECTED_POSTCHECK_READ_THROW');}return fs.readFileSync(file,...args);}});}}));cases.push(faultCase('POSTCHECK_STAT_FAILURE',{expectHeld:true,expectIo:true,workFactory:({map,manifest,generated})=>{fs.writeFileSync(map,'changed');fs.writeFileSync(manifest,'changed');fs.writeFileSync(generated,'x');throw new Error('TRIGGER_ROLLBACK');},rollbackCheckerFactory:({manifest,flags})=>{let once=true;return proxyWith({statSync:(file,...args)=>{if(file===manifest&&once){once=false;flags.io=true;throw new Error('INJECTED_POSTCHECK_STAT_THROW');}return fs.statSync(file,...args);}});}}));return cases;}
 
function manifestStateR1({expectedRows=[],expectedRunId='',frozenPrefix=null,expectedPhysicalDelta=null}={}){return validateAppendStableManifest(fs.readFileSync(abs(base.MANIFEST)),{anomalyRows:readCsv(base.ANOMALY_AUTHORITY).rows,frozenPrefix,originalRunId:base.ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:expectedRows,expectedRunId,expectedPhysicalDelta,filesystemIdentity:{runIds:expectedRunId?[expectedRunId]:[],get:file=>fs.existsSync(abs(file))?identity(file):null}});}
function protectedRows(){const rows=readCsv(base.PROTECTED_INVENTORY).rows;if(rows.length!==49)throw new Error(`PROTECTED_COUNT:${rows.length}`);return rows.map(row=>({path:row.artifact_path,...identity(row.artifact_path)}));}
export function designInputErrorsR1({requireRelease=false,expectNoExecution=true}={}){const inheritedErrors=base.designInputErrors({requireRelease:false,expectNoExecution}).filter(code=>!code.startsWith('RELEASE_'));const errors=[...inheritedErrors,...formalEntryErrorsR1(),...releaseErrorsR1({required:requireRelease})];for(const file of [CONTRACT,SCHEMA,EXEC_SET])if(!fs.existsSync(abs(file)))errors.push(`INPUT_MISSING:${file}`);if(errors.some(code=>code.startsWith('INPUT_MISSING')))return[...new Set(errors)];const contracts=readCsv(CONTRACT),schemas=readCsv(SCHEMA),set=readCsv(EXEC_SET);errors.push(...exactColumns(contracts,base.CONTRACT_COLUMNS,'CONTRACT_R1'),...compareRows(contracts.rows,contractRowsR1(),base.CONTRACT_COLUMNS,'CONTRACT_R1'),...exactColumns(schemas,base.SCHEMA_COLUMNS,'SCHEMA_R1'),...compareRows(schemas.rows,schemaRowsR1(),base.SCHEMA_COLUMNS,'SCHEMA_R1'),...exactColumns(set,base.EXEC_SET_COLUMNS,'EXEC_SET_R1'),...compareRows(set.rows,executionSetRowsR1(),base.EXEC_SET_COLUMNS,'EXEC_SET_R1'));const fault=transactionFaultRows();if(fault.length!==9||fault.some(row=>row.result!=='PASS'))errors.push('TRANSACTION_FAULT_HARNESS');if(expectNoExecution&&manifestStateR1().logicalRows.some(row=>row.run_id===base.EXEC_RUN))errors.push('EXECUTION_MANIFEST_ROWS');return[...new Set(errors)];}
 
function baselineRowsR1(){const source=base.auditEntry(base.SOURCE_AUDIT),release=base.auditEntry(RELEASE_AUDIT),manifest=fs.readFileSync(abs(base.MANIFEST)),mapBefore=identity(base.CASE_MAP);if(!source||!release)throw new Error('AUDIT_ENTRY_MISSING');const rows=[{baseline_id:'P0INTR1-BASE-001',identity_type:'SOURCE_EXECUTION_AUDIT_ENTRY',artifact_path:`${base.AUDIT_REPORT}#L${source.start}-L${source.end}`,rows:String(source.lines),bytes:String(source.bytes),sha256:source.sha256,mtime:'INFO_APPENDABLE_SHARED_FILE',required_state:'EXACT_SOURCE_AUTHORITY_MATCH'},{baseline_id:'P0INTR1-BASE-002',identity_type:'DESIGN_RELEASE_AUDIT_ENTRY',artifact_path:`${base.AUDIT_REPORT}#L${release.start}-L${release.end}`,rows:String(release.lines),bytes:String(release.bytes),sha256:release.sha256,mtime:'INFO_APPENDABLE_SHARED_FILE',required_state:'EXACT_RELEASE_MARKERS'},{baseline_id:'P0INTR1-BASE-003',identity_type:'RAW_MANIFEST_BEFORE_EXECUTION',artifact_path:base.MANIFEST,rows:String(manifestStateR1().logicalDataRows),bytes:String(manifest.length),sha256:hash(manifest),mtime:new Date(Math.trunc(fs.statSync(abs(base.MANIFEST)).mtimeMs)).toISOString(),required_state:'EXACT_APPEND_ONLY_PREFIX'},{baseline_id:'P0INTR1-BASE-004',identity_type:'FORMAL_MAP_BEFORE_EXECUTION',artifact_path:base.CASE_MAP,rows:String(mapBefore.rows),bytes:String(mapBefore.bytes),sha256:mapBefore.sha256,mtime:mapBefore.mtime,required_state:'EXACT45_RESTORABLE'}];for(const file of executionSetRowsR1().slice(0,17).map(row=>row.artifact_path)){const id=identity(file);rows.push({baseline_id:`P0INTR1-BASE-${String(rows.length+1).padStart(3,'0')}`,identity_type:'FROZEN_EXECUTION_INPUT',artifact_path:file,rows:String(id.rows),bytes:String(id.bytes),sha256:id.sha256,mtime:id.mtime,required_state:'EXACT_NO_DRIFT'});}for(const item of protectedRows())rows.push({baseline_id:`P0INTR1-BASE-${String(rows.length+1).padStart(3,'0')}`,identity_type:'PROTECTED_OUTPUT_CURRENT_IDENTITY',artifact_path:item.path,rows:String(item.rows),bytes:String(item.bytes),sha256:item.sha256,mtime:item.mtime,required_state:'NO_MUTATION'});return rows;}
function baselineErrorsR1(rows){const errors=[];if(rows.length!==70)return[`BASELINE_COUNT:${rows.length}:70`];for(const [row,entry,code] of [[rows[0],base.auditEntry(base.SOURCE_AUDIT),'SOURCE'],[rows[1],base.auditEntry(RELEASE_AUDIT),'RELEASE']])if(!entry||row.rows!==String(entry.lines)||row.bytes!==String(entry.bytes)||row.sha256!==entry.sha256)errors.push(`BASELINE_${code}_AUDIT`);const manifest=fs.readFileSync(abs(base.MANIFEST)),prefix=rows[2];if(manifest.length<Number(prefix.bytes)||hash(manifest.subarray(0,Number(prefix.bytes)))!==prefix.sha256)errors.push('BASELINE_MANIFEST_PREFIX');const mapId=identity(base.MAP_BASELINE);if(rows[3].rows!=='45'||rows[3].bytes!==String(mapId.bytes)||rows[3].sha256!==mapId.sha256)errors.push('BASELINE_MAP_BEFORE');for(const row of rows.slice(4)){if(!fs.existsSync(abs(row.artifact_path))){errors.push(`BASELINE_PATH_MISSING:${row.artifact_path}`);continue;}const id=identity(row.artifact_path);if(row.rows!==String(id.rows)||row.bytes!==String(id.bytes)||row.sha256!==id.sha256||Date.parse(row.mtime)!==id.mtimeMs)errors.push(`BASELINE_IDENTITY:${row.artifact_path}`);}return errors;}
function requestTextR1(){return`# Eligible6 formal evidence integration execution review request repair001\n\ncase_id=${base.CASE_ID}\nsource_audit=${base.SOURCE_AUDIT}\nrelease_audit=${RELEASE_AUDIT}\nbatch_id=${base.EXEC_BATCH}\nrun_id=${base.EXEC_RUN}\nnetwork_scope=FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK\nintegration_ceiling=FORMAL_REFERENCE_REGISTRATION_ONLY_GAPS_REMAIN_OPEN_NO_UPGRADE\nmap_effect=APPEND_ONE_REGISTER_ROW_EMAP_046_ONLY\naccepted_reference_rows=6\nheld_candidate=P0DISCR1-CAND-005\nformal_map_before_rows=45\nformal_map_after_rows=46\ngap_summary_rows=7\noccurrence_application_rows=10\ntransaction_fault_tests=9\ngap_state=OPEN_RETAINED_GAP\nclaim_strength_ceiling=PENDING_VERIFICATION_MAX_NO_UPGRADE\nformal_pool_effect=NO_AUTOMATIC_FORMAL_POOL_CHANGE\nevidence_strength_effect=NO_UPGRADE\nbusiness_output_mutation=NONE\nrun_status=EXECUTED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW\n`;}
function validationRowsR1(state){const errors=base.coreErrors(state),faults=transactionFaultRows(),checks=[['CORE_ERRORS','0',String(errors.length)],['DESIGN_INPUT_ERRORS','0','0'],['ACCEPTED_REGISTER','6',String(state.accepted.length)],['HELD_EXCLUDED','0',String(state.accepted.filter(row=>row.candidate_id==='P0DISCR1-CAND-005').length)],['MAP_TARGET','46',String(state.target.length)],['MAP_NEW_ROW','EMAP-046',state.target[45]?.target_row_id??''],['SUMMARY','7',String(state.summary.length)],['APPLICATION','10',String(state.applications.length)],['LEDGER','46',String(state.ledger.length)],['OPEN_GAPS','7',String(state.summary.filter(row=>row.gap_state_after==='OPEN_RETAINED_GAP').length)],['NO_GAP_CLOSURE','7',String(state.summary.filter(row=>row.gap_closure_effect==='NONE_GAP_REMAINS_OPEN').length)],['CLAIM_CEILING','6',String(state.accepted.filter(row=>row.claim_strength_after==='PENDING_VERIFICATION_MAX_NO_UPGRADE').length)],['POOL_BOUNDARY','6',String(state.accepted.filter(row=>row.formal_pool_effect==='NO_AUTOMATIC_FORMAL_POOL_CHANGE').length)],['EVIDENCE_BOUNDARY','6',String(state.accepted.filter(row=>row.evidence_strength_effect==='NO_UPGRADE').length)],['BUSINESS_OUTPUT_MUTATION','0',String(state.applications.filter(row=>row.business_output_mutation!=='NONE').length)],['TRANSACTION_FAULT_PASS','9',String(faults.filter(row=>row.result==='PASS').length)],['ACTUAL_IO_THROW_CASES','6',String(faults.filter(row=>row.actual_io_throw==='YES').length)],['ROLLBACK_HELD_CASES','5',String(faults.filter(row=>row.actual_result==='ROLLBACK_INCOMPLETE_HELD').length)],['SAFE_STATE_VERIFIED','9',String(faults.filter(row=>row.safe_state_verified==='YES').length)],['EXACT_SET','25',String(executionSetRowsR1().length)],['BASELINE','70','70'],['MANIFEST_DELTA','25','25']];const rows=checks.map((item,index)=>({check_id:`P0INTR1-EXEC-VAL-${String(index+1).padStart(3,'0')}`,check_description:item[0],expected:item[1],actual:item[2],status:item[1]===item[2]?'PASS':'FAIL',evidence:'ELIGIBLE6_INTEGRATION_REPAIR001_REAL_IO_FAIL_CLOSED'}));rows.push({check_id:'P0INTR1-EXEC-VAL-023',check_description:'SELF_REFERENCE_EXCLUDED',expected:'SELF_REFERENCE_EXCLUDED',actual:'SELF_REFERENCE_EXCLUDED',status:'INFO',evidence:'validation and manifest identities postchecked'});return rows;}
function manifestRowsForR1(paths){return paths.map(file=>{const id=identity(file);return{case_id:base.CASE_ID,run_id:base.EXEC_RUN,batch_id:base.EXEC_BATCH,artifact_path:file,sha256:id.sha256,bytes:String(id.bytes),mtime:id.mtime};});}
 
export function validateExecutionR1(){const errors=[];for(const file of base.GENERATED)if(!fs.existsSync(abs(file)))errors.push(`MISSING:${file}`);if(errors.length)return errors;const baseline=readCsv(base.EXEC_BASELINE),accepted=readCsv(base.ACCEPTED_REGISTER),summary=readCsv(base.GAP_SUMMARY),applications=readCsv(base.APPLICATION),ledger=readCsv(base.CHANGE_LEDGER),validation=readCsv(base.EXEC_VALIDATION),target=readCsv(base.MAP_TARGET).rows,mapRows=readCsv(base.CASE_MAP),state={eligible:accepted.rows,target,accepted:accepted.rows,summary:summary.rows,applications:applications.rows,ledger:ledger.rows,mapRows:mapRows.rows};errors.push(...exactColumns(baseline,base.BASELINE_COLUMNS,'BASELINE'),...baselineErrorsR1(baseline.rows),...exactColumns(accepted,base.ELIGIBLE_COLUMNS,'REGISTER'),...exactColumns(summary,base.GAP_SUMMARY_COLUMNS,'SUMMARY'),...exactColumns(applications,base.APPLICATION_COLUMNS,'APPLICATION'),...exactColumns(ledger,base.LEDGER_COLUMNS,'LEDGER'),...exactColumns(mapRows,base.MAP_COLUMNS,'FORMAL_MAP'),...exactColumns(validation,base.VALIDATION_COLUMNS,'VALIDATION'),...base.coreErrors(state));if(fs.readFileSync(abs(base.CASE_MAP),'utf8')!==base.serializeMap(base.mapRowsFromTarget(target)))errors.push('FORMAL_MAP_SERIALIZATION');if(normalize(fs.readFileSync(abs(base.EXEC_REQUEST)))!==requestTextR1())errors.push('REQUEST_TEXT');if(validation.rows.length!==23||validation.rows.some(row=>row.status==='FAIL'))errors.push('VALIDATION_STATUS');const expected=manifestRowsForR1(executionSetRowsR1().map(row=>row.artifact_path)),prefix=baseline.rows[2],manifest=manifestStateR1({expectedRows:expected,expectedRunId:base.EXEC_RUN,frozenPrefix:{bytes:Number(prefix.bytes),sha256:prefix.sha256},expectedPhysicalDelta:25});errors.push(...manifest.errors.map(code=>`MANIFEST:${code}`));return[...new Set(errors)];}
export function executeR1({token}={}){if(token!==base.EXEC_TOKEN)throw new Error('EXECUTION_TOKEN_MISMATCH');const pre=designInputErrorsR1({requireRelease:true,expectNoExecution:true});if(pre.length)throw new Error(`PREWRITE:${pre.join('|')}`);const manifestPath=abs(base.MANIFEST),mapPath=abs(base.CASE_MAP),snapshots=[{file:manifestPath,buffer:fs.readFileSync(manifestPath),stat:fs.statSync(manifestPath)},{file:mapPath,buffer:fs.readFileSync(mapPath),stat:fs.statSync(mapPath)}],removePaths=base.GENERATED.map(abs);return runFailClosedTransactionR1({snapshots,removePaths,work:()=>{write(base.EXEC_BASELINE,serializeCsv(baselineRowsR1(),base.BASELINE_COLUMNS));const accepted=readCsv(base.ELIGIBLE_AUTHORITY).rows,target=readCsv(base.MAP_TARGET).rows,derived=base.deriveOutputs(accepted),ledger=base.ledgerRows(readCsv(base.MAP_BASELINE).rows,target),mapRows=base.mapRowsFromTarget(target),state={eligible:accepted,target,accepted,summary:derived.summary,applications:derived.applications,ledger,mapRows};write(base.ACCEPTED_REGISTER,serializeCsv(accepted,base.ELIGIBLE_COLUMNS));write(base.GAP_SUMMARY,serializeCsv(derived.summary,base.GAP_SUMMARY_COLUMNS));write(base.APPLICATION,serializeCsv(derived.applications,base.APPLICATION_COLUMNS));write(base.CHANGE_LEDGER,serializeCsv(ledger,base.LEDGER_COLUMNS));write(base.CASE_MAP,base.serializeMap(mapRows));write(base.EXEC_REQUEST,requestTextR1());const validation=validationRowsR1(state);write(base.EXEC_VALIDATION,serializeCsv(validation,base.VALIDATION_COLUMNS));if(validation.some(row=>row.status==='FAIL'))throw new Error('VALIDATION_FAIL');const rows=manifestRowsForR1(executionSetRowsR1().map(row=>row.artifact_path)),candidate=Buffer.concat([snapshots[0].buffer,Buffer.from(serializeManifestDataRows(rows),'utf8')]),candidateState=validateAppendStableManifest(candidate,{anomalyRows:readCsv(base.ANOMALY_AUTHORITY).rows,frozenPrefix:{bytes:snapshots[0].buffer.length,sha256:hash(snapshots[0].buffer)},originalRunId:base.ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:rows,expectedRunId:base.EXEC_RUN,expectedPhysicalDelta:25});if(candidateState.errors.length)throw new Error(`MANIFEST_CANDIDATE:${candidateState.errors.join('|')}`);fs.writeFileSync(manifestPath,candidate);const post=validateExecutionR1();if(post.length)throw new Error(`POSTWRITE:${post.join('|')}`);return{status:'EXECUTED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW',accepted_reference_rows:6,held_candidate:'P0DISCR1-CAND-005',map_before_rows:45,map_after_rows:46,gaps_open:7,transaction_fault_tests:9,manifest_rows:25};}});}
 
export function negativeRowsR1(){return[...base.negativeRows(),...transactionFaultRows().map((row,index)=>({test_id:`P0INTR1-NEG-${String(index+20).padStart(3,'0')}-${row.failure_stage}`,mutation_applied:row.failure_stage==='CLEAN_ROLLBACK_CONTROL'?'NO_CLEAN_CONTROL':'YES',oracle:'runFailClosedTransactionR1',expected:'PASS',expected_code:row.expected_result,actual:row.result,actual_codes:`${row.actual_result}|${row.exact_error_class}|SAFE:${row.safe_state_verified}`,result:row.result}))];}
 
if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href){const mode=process.argv[2]??'--preview',token=process.argv.find(value=>value.startsWith('--token='))?.slice(8);if(mode==='--preview'){const eligible=base.eligibleRows(),target=base.mapTargetRows(readCsv(base.MAP_BASELINE).rows),derived=base.deriveOutputs(eligible),errors=base.coreErrors({eligible,target,accepted:eligible,summary:derived.summary,applications:derived.applications,ledger:base.ledgerRows(readCsv(base.MAP_BASELINE).rows,target),mapRows:base.mapRowsFromTarget(target)}),faults=transactionFaultRows();console.log(JSON.stringify({status:errors.length||faults.some(row=>row.result!=='PASS')?'FAIL':'PREVIEW_PASS',eligible:6,held:1,map_before:45,map_after:46,summary:7,applications:10,ledger:46,contracts:contractRowsR1().length,schemas:schemaRowsR1().length,exact_set:executionSetRowsR1().length,transaction_fault_tests:faults.length,errors,faults},null,2));if(errors.length||faults.some(row=>row.result!=='PASS'))process.exitCode=1;}else if(mode==='--self-test'){const rows=negativeRowsR1();console.log(JSON.stringify({status:rows.every(row=>row.result==='PASS')?'SELF_TEST_PASS':'FAIL',tests:rows.length,rows},null,2));if(rows.some(row=>row.result!=='PASS'))process.exitCode=1;}else if(mode==='--validate-design-inputs'){const errors=designInputErrorsR1({requireRelease:false,expectNoExecution:true});console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_DESIGN_INPUTS',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--validate-release'){const errors=designInputErrorsR1({requireRelease:true,expectNoExecution:true});console.log(JSON.stringify({status:errors.length?'HELD':'PASS_RELEASE_FROZEN_LOCAL_INPUTS',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--execute')console.log(JSON.stringify(executeR1({token}),null,2));else if(mode==='--validate-execution'){const errors=validateExecutionR1();console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_APPEND_STABLE_EXECUTION_STATE',errors},null,2));if(errors.length)process.exitCode=1;}else throw new Error(`UNKNOWN_MODE:${mode}`);}