103 lines
21 KiB
Rust
103 lines
21 KiB
Rust
//! Grating2 / immutableH5613 currentG2:12 actual static callers plus2 genuine foreign-neighbor states;14 endpoints/2 ordered views. Own health0 remains intact, World0/newQA0/newart0.
|
|
use std::{collections::{BTreeMap,BTreeSet},fs,io::{Read,Write},path::Path};
|
|
use raptor_replica::{assets::{Catalog,Sprite},content::Registry,hd::{HdAssets,OriginalDetailCells,OriginalPalette},render::{Canvas,upscale},terrain_hd::{logical_sprite,selected_art,TerrainHd,Replacement,RetainedOriginalPlacement,PaletteConstraintPlacement,OverlayResult}};
|
|
use serde_json::{Value,json};
|
|
#[derive(Clone)]struct Layer{image:Sprite,retained:Option<OriginalDetailCells>,domain:Option<OriginalPalette>,record:Value}
|
|
fn read(p:&Path)->Value{serde_json::from_slice(&fs::read(p).unwrap()).unwrap()}
|
|
fn id(v:&Value)->u32{u32::from_str_radix(v.as_str().unwrap(),16).unwrap()}
|
|
fn class(v:u16)->u8{match v{0..=239=>0,240..=244=>1,245..=249=>2,_=>v as u8}}
|
|
fn gz(b:&[u8])->Vec<u8>{let mut z=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());z.write_all(b).unwrap();z.finish().unwrap()}
|
|
fn emit(out:&Path,name:&str,image:&Sprite,pal:&[[u8;3];256])->Value{let mut b=Vec::new();let mut c=Vec::new();let mut ppm=format!("P6\n{} {}\n255\n",image.width,image.height).into_bytes();for &v in &image.pixels{assert!(v<256);b.extend(v.to_le_bytes());c.push(class(v));ppm.extend(pal[v as usize]);}let ip=format!("{name}.indices-u16le.gz");let cp=format!("{name}.classes-u8.gz");let rp=format!("{name}.ppm.gz");fs::write(out.join(&ip),gz(&b)).unwrap();fs::write(out.join(&cp),gz(&c)).unwrap();fs::write(out.join(&rp),gz(&ppm)).unwrap();json!({"width":image.width,"height":image.height,"indexed":ip,"classes":cp,"PPM":rp})}
|
|
fn support(ids:&[u32],own:&BTreeSet<u32>,active:&BTreeSet<u32>)->Vec<[usize;4]>{let at=|x:i32,y:i32|->Option<usize>{if x<0||y<0||x>=3||y>=3{None}else{Some(y as usize*3+x as usize)}};let mut r=BTreeSet::new();for(t,v)in ids.iter().enumerate(){if !own.contains(v){continue}let tx=(t%3)as i32;let ty=(t/3)as i32;r.insert([t%3*32,t/3*32,(t%3+1)*32,(t/3+1)*32]);for(dx,dy)in[(-1,0),(1,0),(0,-1),(0,1)]{let Some(q)=at(tx+dx,ty+dy)else{continue};if !active.contains(&ids[q])||own.contains(&ids[q]){continue}let x=q%3*32;let y=q/3*32;r.insert(match(dx,dy){(-1,0)=>[x+30,y+2,x+32,y+30],(1,0)=>[x,y+2,x+2,y+30],(0,-1)=>[x+2,y+30,x+30,y+32],_=>[x+2,y,x+30,y+2]});}for vy in[ty,ty+1]{for vx in[tx,tx+1]{let pos=[(vx-1,vy-1),(vx,vy-1),(vx-1,vy),(vx,vy)];let slots:Option<Vec<_>>=pos.iter().map(|&(x,y)|at(x,y)).collect();let Some(slots)=slots else{continue};if !slots.iter().all(|q|active.contains(&ids[*q])){continue}for(&q,&(px,py))in slots.iter().zip(pos.iter()){if own.contains(&ids[q]){continue}let x=q%3*32+if px==vx{0}else{30};let y=q/3*32+if py==vy{0}else{30};r.insert([x,y,x+2,y+2]);}}}}r.into_iter().collect()}
|
|
fn compose(control:&Sprite,ids:&[u32],s:usize,layers:&BTreeMap<(u32,usize),Layer>,allowed:&BTreeSet<u32>,pal:&[[u8;3];256])->(Sprite,Value){let(mut parts,mut retained,mut domains,mut used)=(Vec::new(),Vec::new(),Vec::new(),Vec::new());for(t,&asset)in ids.iter().enumerate(){if !allowed.contains(&asset){continue}let l=&layers[&(asset,s)];let n=parts.len();if let Some(d)=&l.retained{retained.push(RetainedOriginalPlacement{replacement_index:n,details:d.clone()});}if let Some(p)=&l.domain{domains.push(PaletteConstraintPlacement{replacement_index:n,palette:p.clone()});}parts.push(Replacement{image:l.image.clone(),position:[(t%3*32)as i32,(t/3*32)as i32],logical_size:[32,32]});used.push(json!({"slot":t,"asset":format!("{asset:05x}"),"position":[t%3*32,t/3*32],"component":l.record,"retained_cells":l.retained.as_ref().map(|d|d.cells()),"palette_domain":l.domain.as_ref().map(|d|d.indices())}));}
|
|
let composed=TerrainHd::default().compose_with_palette_constraints(control,&parts,&retained,&domains,s,pal);assert!(composed.results.iter().all(|r|*r==OverlayResult::Applied),"{:?}",composed.results);let mut rc=0;let mut dc=0;for r in &retained{let p=&parts[r.replacement_index];for &[x,y]in r.details.cells(){for dy in 0..s{for dx in 0..s{let xx=(p.position[0]as usize+x as usize)*s+dx;let yy=(p.position[1]as usize+y as usize)*s+dy;assert_eq!(composed.image.pixels[yy*control.width+xx],control.pixels[yy*control.width+xx],"retained OriginalNx after every join");rc+=1;}}}}for d in &domains{let p=&parts[d.replacement_index];for y in 0..32*s{for x in 0..32*s{let i=(p.position[1]as usize*s+y)*control.width+p.position[0]as usize*s+x;assert!(d.palette.contains(composed.image.pixels[i]),"joined owner escaped SourceE palette domain");dc+=1;}}}(composed.image,json!({"pre_blit":used,"retained_OriginalNx_samples":rc,"palette_domain_samples":dc}))}
|
|
// Exact public frame metadata is checked before accepting trusted details/domains.
|
|
fn metadata_stage(frame:&Value,retained:&Option<OriginalDetailCells>,domain:&Option<OriginalPalette>){
|
|
let expected:Vec<[u32;2]>=frame.get("original_detail_cells").and_then(|v|v.as_array()).map(|v|v.iter().map(|p|[p[0].as_u64().unwrap()as u32,p[1].as_u64().unwrap()as u32]).collect()).unwrap_or_default();
|
|
assert_eq!(retained.as_ref().map(|d|d.cells()).unwrap_or(&[]),expected.as_slice(),"trusted details match full native frame");
|
|
let opted=frame.get("palette_constraint").is_some_and(|v|!v.is_null());
|
|
assert_eq!(domain.is_some(),opted,"foreign/native palette domain must not be discarded");
|
|
if opted{assert_eq!(frame["palette_constraint"],"original-painted-ordinary-v1");}
|
|
}
|
|
fn bank_indices(bank:&Value,asset:u32,scale:usize)->Vec<u16>{
|
|
let row=bank.as_array().unwrap().iter().find(|r|id(&r["asset"])==asset).unwrap();
|
|
let rec=row["scales"].as_array().unwrap().iter().find(|r|r["scale"].as_u64()==Some(scale as u64)).unwrap();
|
|
assert_eq!([rec["width"].as_u64().unwrap(),rec["height"].as_u64().unwrap()],[(32*scale)as u64,(32*scale)as u64]);
|
|
rec["indices"].as_array().unwrap().iter().map(|v|v.as_u64().unwrap()as u16).collect()
|
|
}
|
|
|
|
|
|
|
|
fn save(p:&Path,v:&Value){fs::write(p,serde_json::to_vec_pretty(v).unwrap()).unwrap();}
|
|
// No default execution mode. Both modes require a separate, hash-bound true Root input.
|
|
fn activation(input:&Value){
|
|
assert_eq!(input["status"],"ROOT_ACTIVATED_SOURCEG2_GRATING2_GENUINE14_H5613");
|
|
assert_eq!(input["Root_GO"],true);
|
|
assert_eq!(input["Root_authorized_selected_assets"],json!(["203c6","203c7"]));
|
|
assert!(input["Root_actual_H5613_GO"]["sha256"].is_string());
|
|
assert!(input["baseline_hardlink_identity"]["sha256"].is_string());
|
|
assert!(input["baseline_hd"]["sha256"].is_string());
|
|
assert!(input["baseline_provenance"]["sha256"].is_string());
|
|
assert_eq!(input["actual_baseline_frame_count"],5613);
|
|
assert!(input["baseline_finite_native"].is_array());
|
|
}
|
|
fn compose_mode(args:Vec<String>){
|
|
assert_eq!(args.len(),6,"DATA ACTUAL_H5613_PACK LATE7_PACK ROOT_ACTIVATED_INPUT FRESH_OUT");
|
|
let input=read(Path::new(&args[4]));activation(&input);
|
|
assert_eq!(input["original_data_root"],args[1]);assert_eq!(input["baseline_pack_root"],args[2]);assert_eq!(input["own_pack_root"],args[3]);assert_eq!(input["actual_output_root"],args[5]);
|
|
let contract=read(Path::new(input["source_contract"]["path"].as_str().unwrap()));
|
|
assert_eq!(contract["status"],"ROOT_ACTIVATED_SOURCEG2_GRATING2_GENUINE14_H5613");
|
|
let own:BTreeSet<u32>=contract["selected"].as_array().unwrap().iter().map(id).collect();assert_eq!(own,[0x203c6,0x203c7].into_iter().collect());
|
|
let source_assets:BTreeSet<u32>=contract["source_assets"].as_array().unwrap().iter().map(id).collect();assert_eq!(source_assets.len(),55);
|
|
let literal=read(&Path::new(&args[2]).join("hd.json"));let mut baseids=BTreeSet::new();let mut native_frames=BTreeMap::<u32,Value>::new();let mut native_sequences=BTreeMap::<u32,Value>::new();
|
|
for seq in literal["sequences"].as_array().unwrap(){for f in seq["frames"].as_array().unwrap(){let asset=seq["base_asset"].as_u64().unwrap()as u32+f["frame"].as_u64().unwrap()as u32;baseids.insert(asset);assert!(native_frames.insert(asset,f.clone()).is_none());native_sequences.insert(asset,seq.clone());}}
|
|
assert_eq!(baseids.len(),5613);assert!(own.is_disjoint(&baseids));
|
|
let foreign:BTreeSet<u32>=source_assets.intersection(&baseids).copied().collect();assert!(own.is_disjoint(&foreign));
|
|
let bindings=input["baseline_finite_native"].as_array().unwrap();let boundids:BTreeSet<u32>=bindings.iter().map(|x|id(&x["asset"])).collect();assert_eq!(bindings.len(),boundids.len());assert_eq!(boundids,foreign);
|
|
for x in bindings{let a=id(&x["asset"]);assert_eq!(&native_frames[&a],&x["frame"],"current full finite native frame");assert_eq!(&native_sequences[&a],&x["full_sequence"],"current full finite native sequence");assert!(x["raw"]["sha256"].is_string());}
|
|
let own_manifest=read(&Path::new(&args[3]).join("hd.json"));assert_eq!(own_manifest["sequences"].as_array().unwrap().len(),2);
|
|
for route in contract["own_routes"].as_array().unwrap(){let asset=id(&route["asset"]);let seq=own_manifest["sequences"].as_array().unwrap().iter().find(|s|s["base_asset"].as_u64()==Some(asset as u64)).unwrap();assert_eq!(seq,&route["private_full_sequence"]);assert_eq!(seq["frame_count"],1);assert_eq!(seq["frames"].as_array().unwrap().len(),1);let f=&seq["frames"][0];assert_eq!(f["frame"],0);assert_eq!(f["logical_width"],32);assert_eq!(f["logical_height"],32);assert_eq!(f["origin"],json!([0,0]));for k in ["palette_constraint","native_nearest_cues","preserve_reserved_coverage","crop","atlas_grid","original_detail_cells"]{assert!(f.get(k).is_none());}assert!(native_frames.insert(asset,f.clone()).is_none());}
|
|
let active_own:BTreeSet<u32>=own.intersection(&source_assets).copied().collect();assert_eq!(active_own.len(),2);let all:BTreeSet<u32>=active_own.union(&foreign).copied().collect();let c=Catalog::open(&args[1]).unwrap();let pal=c.palette().unwrap();let registry=Registry::base(&c).unwrap();let rows=contract["endpoints"].as_array().unwrap();assert_eq!(rows.len(),14);let pairs=contract["ordered_pairs"].as_array().unwrap();assert_eq!(pairs.len(),2);
|
|
let mut Sourcekeys=BTreeSet::new();
|
|
for(row_index,row)in rows.iter().enumerate(){assert_eq!(row["endpoint_index"].as_u64(),Some(row_index as u64));assert!(Sourcekeys.insert(row["Source_key"].as_str().unwrap()));assert_eq!(row["columns"],3);assert_eq!(row["ordered_source_ids"].as_array().unwrap().len(),9);
|
|
assert!(row_index<14);let mission=registry.missions.iter().find(|(k,_)|k.to_string()==row["mission"].as_str().unwrap()).unwrap().1;let cols=mission.columns as usize;let nr=mission.layout.len()/cols;let y=row["row"].as_u64().unwrap()as i32;let x=row["column"].as_u64().unwrap()as i32;let mut real=Vec::new();
|
|
for dy in -1..=1{for dx in -1..=1{let xx=x+dx;let yy=y+dy;real.push(if xx<0||yy<0||xx>=cols as i32||yy>=nr as i32{0}else{mission.tiles[mission.layout[yy as usize*cols+xx as usize]].art.asset.unwrap_or(0)});}}
|
|
let center=&mission.tiles[mission.layout[y as usize*cols+x as usize]];assert!(own.contains(¢er.art.asset.unwrap()));assert_eq!(center.health,0);assert_eq!(center.reward,0);assert_eq!(selected_art(center,true,true,true).asset,center.art.asset,"static grating has no invented destruction state");
|
|
let actors=row["settled_actors"].as_array().unwrap();let mut changed=BTreeSet::new();for a in actors{let ay=a["row"].as_u64().unwrap()as usize;let ax=a["column"].as_u64().unwrap()as usize;let t=&mission.tiles[mission.layout[ay*cols+ax]];let d=&a["Original_tile"];assert_eq!(t.art.asset,Some(id(&d["intact"])));assert_eq!(t.health as i64,d["health"].as_i64().unwrap());assert_eq!(t.reward as i64,d["reward"].as_i64().unwrap());assert!(t.health>0);assert_eq!(selected_art(t,true,true,false).asset,t.art.asset);let settled=selected_art(t,true,true,true).asset.unwrap();assert_eq!(settled,id(&d["settled"]));let sy=ay as i32-y+1;let sx=ax as i32-x+1;assert!((0..3).contains(&sx)&&(0..3).contains(&sy));let slot=sy as usize*3+sx as usize;assert!(changed.insert(slot));real[slot]=settled;}
|
|
|
|
let expected:Vec<_>=row["ordered_source_ids"].as_array().unwrap().iter().map(|v|if v.is_null(){0}else{id(v)}).collect();assert_eq!(real,expected,"literal genuine Registry endpoint");let count=expected.iter().filter(|a|own.contains(a)).count();assert!(if row["role"]=="authentic_static_intact"{count>=1&&actors.is_empty()}else{count>=1&&actors.len()==1});
|
|
|
|
}
|
|
assert_eq!(pairs.iter().map(|p|p["event_id"].as_str().unwrap()).collect::<BTreeSet<_>>().len(),2);
|
|
for(index,pair)in pairs.iter().enumerate(){assert_eq!(pair["pair_index"].as_u64(),Some(index as u64));assert_eq!(pair["separate_one_cell_state"],true);let b=pair["before_endpoint"].as_u64().unwrap()as usize;let a=pair["settled_endpoint"].as_u64().unwrap()as usize;assert!(a<14&&b<14);assert_eq!(rows[b]["mission"],rows[a]["mission"]);assert_eq!(rows[b]["row"],rows[a]["row"]);assert_eq!(rows[b]["column"],rows[a]["column"]);let diffs:Vec<_>=(0..9).filter(|&i|rows[b]["ordered_source_ids"][i]!=rows[a]["ordered_source_ids"][i]).collect();assert_eq!(diffs,vec![pair["changed_slot"].as_u64().unwrap()as usize]);let d=&pair["Original_actor"];let slot=pair["changed_slot"].as_u64().unwrap()as usize;assert_eq!(rows[b]["ordered_source_ids"][slot],d["intact"]);assert_eq!(rows[a]["ordered_source_ids"][slot],d["settled"]);let ay=pair["actor_position"][0].as_u64().unwrap()as i64;let ax=pair["actor_position"][1].as_u64().unwrap()as i64;assert_eq!([ay,ax],[rows[a]["row"].as_i64().unwrap()+slot as i64/3-1,rows[a]["column"].as_i64().unwrap()+slot as i64%3-1]);assert!(rows[a]["settled_actors"].as_array().unwrap().iter().any(|v|v["Original_tile"]==*d&&v["row"]==pair["actor_position"][0]&&v["column"]==pair["actor_position"][1]));}
|
|
let out=Path::new(&args[5]);assert!(!out.exists());fs::create_dir(out).unwrap();fs::create_dir(out.join("components")).unwrap();fs::create_dir(out.join("planes")).unwrap();fs::write(out.join("actual-palette-rgb.bin"),pal.iter().flat_map(|v|v.iter().copied()).collect::<Vec<_>>()).unwrap();
|
|
let mut base=HdAssets::load_lazy(Path::new(&args[2]),&c,None);let mut proposal=HdAssets::load_lazy(Path::new(&args[3]),&c,None);assert!(base.diagnostics.is_empty()&&proposal.diagnostics.is_empty());assert_eq!(base.registered_count(),5613);assert_eq!(proposal.registered_count(),2);
|
|
let mut measured=BTreeMap::new();for q in input["actual_selected_plain_index_banks"].as_array().unwrap(){let asset=id(&q["asset"]);let bank=read(Path::new(q["actual_bank"]["path"].as_str().unwrap()));let row=bank.as_array().unwrap().iter().find(|r|id(&r["asset"])==asset).unwrap();assert!(measured.insert(asset,json!([row])).is_none());}assert_eq!(measured.len(),2);let mut layers=BTreeMap::new();let mut caches=Vec::new();let mut stage_checks=Vec::new();
|
|
for &asset in &all{let src=c.sprite(asset).unwrap();assert_eq!((src.width,src.height),(32,32));for s in 1..=4{let hd=if own.contains(&asset){&mut proposal}else{&mut base};let(image,retained,domain)=hd.terrain_sprite_with_palette(asset,s,&pal).unwrap().unwrap();assert_eq!((image.width,image.height),(32*s,32*s));metadata_stage(&native_frames[&asset],&retained,&domain);
|
|
if let Some(d)=&domain{assert!(src.pixels.iter().all(|p|*p<240));assert_eq!(d.indices().into_iter().collect::<BTreeSet<_>>(),src.pixels.iter().copied().collect());assert!(image.pixels.iter().all(|v|d.contains(*v)));}
|
|
if own.contains(&asset){assert!(domain.is_none());assert!(retained.is_none());assert_eq!(image.pixels,bank_indices(&measured[&asset],asset,s),"Public terrain prejoin API image equals the literal actual derived G2 native bank; own frames have no retention metadata.");stage_checks.push(json!({"asset":format!("{asset:05x}"),"scale":s,"prejoin_exact_selected_asset_inherited_actual_plain_bank":true,"no_Original_functional_retention_selected":true,"palette_domain_absent_selected_plain":true}));}
|
|
let mut record=emit(&out.join("components"),&format!("{asset:05x}-s{s}"),&image,&pal);record["component_stage"]=json!("PUBLIC_TERRAIN_PREJOIN_WITH_PALETTE_ALREADY_APPLIED_AND_TRUSTED_RETENTION_METADATA");record["full_native_frame"]=native_frames[&asset].clone();record["asset"]=json!(format!("{asset:05x}"));record["scale"]=json!(s);record["retained_cells"]=json!(retained.as_ref().map(|d|d.cells()));record["palette_domain"]=json!(domain.as_ref().map(|d|d.indices()));record["actual_derived_graycast2_native_route"]=json!(own.contains(&asset));caches.push(record.clone());layers.insert((asset,s),Layer{image,retained,domain,record});
|
|
}}
|
|
let mut records=Vec::new();for row in rows{let n=row["endpoint_index"].as_u64().unwrap();let ids:Vec<_>=row["ordered_source_ids"].as_array().unwrap().iter().map(|v|if v.is_null(){0}else{id(v)}).collect();let regions=support(&ids,&own,&all);let mut canvas=Canvas{scale:1,image:Sprite{width:96,height:96,pixels:vec![0;96*96]}};for(t,&v)in ids.iter().enumerate(){if v!=0{canvas.blit(&c.sprite(v).unwrap(),(t%3*32)as i32,(t/3*32)as i32);}}
|
|
for s in 1..=4{let original=upscale(&canvas.image,s).unwrap();let(b,binfo)=compose(&original,&ids,s,&layers,&foreign,&pal);let(p,pinfo)=compose(&original,&ids,s,&layers,&all,&pal);let(mut outside,mut fallback,mut padding,mut interior,mut delta,mut base_original_owner)=(0,0,0,0,0,0);
|
|
|
|
for i in 0..original.pixels.len(){let v=original.pixels[i];assert_eq!(class(b.pixels[i]),class(v));assert_eq!(class(p.pixels[i]),class(v));if v>=250{assert_eq!(b.pixels[i],v);assert_eq!(p.pixels[i],v);}let x=i%original.width;let y=i/original.width;let tile=ids[y/(32*s)*3+x/(32*s)];
|
|
if own.contains(&tile){assert_eq!(b.pixels[i],v,"baseline selected2 owner remains Original fallback");base_original_owner+=1;}
|
|
if !all.contains(&tile){assert_eq!(b.pixels[i],v);assert_eq!(p.pixels[i],v);fallback+=1;}if tile==0{assert_eq!(v,0);padding+=1;}
|
|
let ok=regions.iter().any(|r|x>=r[0]*s&&x<r[2]*s&&y>=r[1]*s&&y<r[3]*s);if !ok{assert_eq!(b.pixels[i],p.pixels[i]);outside+=1;}
|
|
if !own.contains(&tile)&&x%(32*s)>=2*s&&x%(32*s)<30*s&&y%(32*s)>=2*s&&y%(32*s)<30*s{assert_eq!(b.pixels[i],p.pixels[i]);interior+=1;}
|
|
if b.pixels[i]!=p.pixels[i]{assert!(ok);delta+=1;}
|
|
}
|
|
let mut corners=Vec::new();let(mut foreign_edge_delta,mut foreign_corner_delta)=(0usize,0usize);
|
|
for vy in 1..=2{for vx in 1..=2{let slots=[(vy-1)*3+vx-1,(vy-1)*3+vx,vy*3+vx-1,vy*3+vx];let touches=slots.iter().any(|q|own.contains(&ids[*q]));if !touches{continue}let active_before=slots.iter().all(|q|foreign.contains(&ids[*q]));let active_after=slots.iter().all(|q|all.contains(&ids[*q]));let mut changes=0;for &q in &slots{if own.contains(&ids[q]){continue}let xx=q%3*32+if q%3==vx{0}else{30};let yy=q/3*32+if q/3==vy{0}else{30};for y in yy*s..(yy+2)*s{for x in xx*s..(xx+2)*s{let i=y*original.width+x;if b.pixels[i]!=p.pixels[i]{assert!(active_after);changes+=1;}}}}foreign_corner_delta+=changes;corners.push(json!({"vertex":[vx,vy],"slots":slots,"active_baseline":active_before,"active_proposal":active_after,"foreign_corner_delta_samples":changes}));}}
|
|
for i in 0..original.pixels.len(){let x=i%original.width;let y=i/original.width;let tile=ids[y/(32*s)*3+x/(32*s)];if own.contains(&tile)||b.pixels[i]==p.pixels[i]{continue}let lx=x%(32*s);let ly=y%(32*s);if (lx>=2*s&&lx<30*s)||(ly>=2*s&&ly<30*s){foreign_edge_delta+=1;}}
|
|
let mut planes=serde_json::Map::new();for(role,img)in[("Original_joined_SourceNx",&original),("actual_H5613_baseline",&b),("selected_derived_grating2_proposal",&p)]{planes.insert(role.into(),emit(&out.join("planes"),&format!("endpoint{n:02}-s{s}-{role}"),img,&pal));}
|
|
records.push(json!({"endpoint_index":n,"Source_key":row["Source_key"],"scale":s,"endpoint":row,"planes":planes,"baseline_inputs":binfo,"proposal_inputs":pinfo,"support_rectangles":regions,"source_classes_reserved250to255_exact":true,"baseline_original_owner_samples_exact":base_original_owner,"fallback_samples_exact":fallback,"padding_samples_exact":padding,"outside_support_samples_exact":outside,"broad_foreign_interior_samples_exact":interior,"delta_samples":delta,"foreign_noncorner_edge_delta_samples":foreign_edge_delta,"foreign_corner_delta_samples":foreign_corner_delta,"four_HD_corner_stencils":corners,"genuine_endpoint":true,"private_or_gallery_probe":false}));
|
|
}
|
|
}
|
|
assert_eq!(records.len(),56);assert!(base.diagnostics.is_empty()&&proposal.diagnostics.is_empty());
|
|
save(&out.join("ACTUAL-SOURCEG2-GRATING2-GENUINE14-56-SCALES-168-PLANES-2VIEWS-2EVENTS.json"),&json!({"status":"ACTUAL_TECHNICAL_OUTPUT_NOT_PHYSICAL_APPROVAL","SourceG2_domain_aware_public_API":true,"baseline_pack_root":args[2],"activation":input,"source_contract":contract,"components":caches,"records":records,"ordered_pairs":contract["ordered_pairs"],"whole_endpoint_role_count":3,"genuine_Source_endpoints":14,"private_or_World_probes":0,"ordered_comparisons":2,"distinct_damage_events":2,"own_used2_prejoin_exact_actual_derived_G2_rows":true,"all12_static_callers_plus2_genuine_foreign_neighbor_events":true,"own_and_registered_stage_checks":stage_checks,"final_retained_expected_is_whole_joined_SourceNx":true,"all_endpoints_fresh_immutable_H5613_no_old_context_output_carry":true,"diagnostics":[],"generic_QA_or_World_or_new_intrinsic_measurements":0}));
|
|
println!("ACTUAL SourceG2 grating2 genuine14;56scales168planes2views2events; selected2allUsed; compile1 constructor1 World0 QA0");
|
|
}
|
|
fn main(){let args:Vec<_>=std::env::args().collect();compose_mode(args);}
|