pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/motion-shader.js

@@ -0,0 +1,40 @@
+import { TRACE_PARAMETERS_SHADER, TRACE_RANDOM_SHADER } from "./path-shader.js";
+/** Same primary visibility/sample sequence as transport; writes a separate bounded plane. */
+export const MOTION_SHADER = TRACE_PARAMETERS_SHADER +
+    TRACE_RANDOM_SHADER +
+    /* wgsl */ String.raw `
+@group(0) @binding(6) var<storage,read_write> motionOutput:array<vec4f>;
+@group(0) @binding(7) var<uniform> motionParams:TraceParameters;
+@group(0) @binding(8) var motionPrimary:texture_2d<f32>;
+@compute @workgroup_size(8,8)
+fn motionMain(@builtin(global_invocation_id) invocation:vec3u){
+ let width=u32(motionParams.screen.x);let height=u32(motionParams.screen.y);
+ if(invocation.x>=width||invocation.y>=height){return;}
+ let index=invocation.y*width+invocation.x;motionOutput[index]=vec4f(0);
+ if(motionParams.previousOrigin.w<0.5){return;}
+ var seed=index*1973u+u32(motionParams.screen.z)*9277u+89173u;
+ var jitter=vec2f(traceRandom(&seed),traceRandom(&seed));
+ if(motionParams.flags.x>0.5){jitter=vec2f(0.5+motionParams.forward.w,0.5+motionParams.right.w);}
+ let pixel=((vec2f(invocation.xy)+jitter)/vec2f(f32(width),f32(height)))*2.0-vec2f(1);
+ let direction=normalize(motionParams.forward.xyz+motionParams.right.xyz*pixel.x-motionParams.up.xyz*pixel.y);
+ let cosine=max(dot(direction,motionParams.forward.xyz),1e-5);
+ let origin=motionParams.origin.xyz+direction*(motionParams.screen.w/cosine);
+ var hit:SurfaceHit;
+ if(motionParams.flags.x>0.5){
+  let primary=textureLoad(motionPrimary,vec2i(invocation.xy),0);
+  if(primary.y< -1.5){hit=traceSurface(origin,direction,(motionParams.settings.w-motionParams.screen.w)/cosine,u32(motionParams.counts.x),u32(motionParams.counts.y),traceRandom(&seed));}
+  else{hit=SurfaceHit(abs(primary.x),i32(primary.y),vec3f(1.0-primary.z-primary.w,primary.z,primary.w),primary.x>=0.0);}
+ }else{
+  hit=traceSurface(origin,direction,(motionParams.settings.w-motionParams.screen.w)/cosine,u32(motionParams.counts.x),u32(motionParams.counts.y),traceRandom(&seed));
+ }
+ if(hit.index<0){return;}
+ let offset=u32(motionParams.counts.y)*18u+u32(hit.index)*3u;
+ let a=surfaceGeometry[offset];let b=surfaceGeometry[offset+1u];let c=surfaceGeometry[offset+2u];
+ if(a.w<0.5){return;}
+ let previous=a.xyz*hit.bary.x+b.xyz*hit.bary.y+c.xyz*hit.bary.z;
+ let clip=mat4x4f(motionParams.previousView0,motionParams.previousView1,motionParams.previousView2,motionParams.previousView3)*vec4f(previous,1);
+ if(clip.w<=0.0){return;}
+ let uv=clip.xy/clip.w*vec2f(0.5,-0.5)+vec2f(0.5);
+ motionOutput[index]=vec4f(uv,length(previous-motionParams.previousOrigin.xyz),1);
+}
+`;

package/lib/renderer/path-shader.js

@@ -0,0 +1,196 @@
+/** Shared path and raster-visibility hybrid integrator. Core surface/BVH/BSDF are concatenated before this module. */
+export const TRACE_PARAMETER_FLOATS = 92;
+export const TRACE_PARAMETER_BYTES = TRACE_PARAMETER_FLOATS * 4;
+export const TRACE_PARAMETERS_SHADER = /* wgsl */ String.raw `
+struct TraceParameters{
+ origin:vec4f,forward:vec4f,right:vec4f,up:vec4f,background:vec4f,
+ screen:vec4f,counts:vec4f,settings:vec4f,flags:vec4f,
+ view0:vec4f,view1:vec4f,view2:vec4f,view3:vec4f,
+ environment:vec4f,environment0:vec4f,environment1:vec4f,environment2:vec4f,
+ medium:vec4f,
+ previousView0:vec4f,previousView1:vec4f,previousView2:vec4f,previousView3:vec4f,previousOrigin:vec4f,
+}
+`;
+export const TRACE_RANDOM_SHADER = /* wgsl */ String.raw `
+fn traceRandom(seed:ptr<function,u32>)->f32{*seed=(*seed)*747796405u+2891336453u;let shift=((*seed)>>28u)+4u;let word=(((*seed)>>shift)^(*seed))*277803737u;return min(f32((word>>22u)^word)/4294967296.0,0.99999994);}
+`;
+export const PATH_SHADER = TRACE_PARAMETERS_SHADER +
+    TRACE_RANDOM_SHADER +
+    /* wgsl */ String.raw `
+struct TraceLight{position:vec4f,color:vec4f,extra:vec4f,}
+@group(0) @binding(5) var<storage,read> traceLights:array<TraceLight>;
+struct TraceOutput{faults:atomic<u32>,faultMask:atomic<u32>,faultDetail:atomic<u32>,faultPixel:atomic<u32>,pixels:array<vec4f>,}
+@group(0) @binding(6) var<storage,read_write> traceOutput:TraceOutput;
+@group(0) @binding(7) var<uniform> traceParams:TraceParameters;
+@group(0) @binding(8) var primaryHits:texture_2d<f32>;
+@group(0) @binding(9) var<storage,read> environmentImportance:array<vec4f>;
+override traceVolumeEnabled:bool=false;
+override traceCaptureFault:bool=false;
+fn traceMediumIor(id:u32)->f32{if(id==0u){return 1.0;}return traceLights[u32(traceParams.medium.x)+id-1u].position.x;}
+fn traceMediumSigma(id:u32)->vec3f{if(id==0u){return vec3f(0);}return traceLights[u32(traceParams.medium.x)+id-1u].position.yzw;}
+fn traceShadowBeer(media:TraceShadowMedia,geometric:vec3f,direction:vec3f,distance:f32)->vec3f{
+ if(!traceVolumeEnabled){return vec3f(1);}return exp(-select(media.incident,media.transmitted,dot(geometric,direction)<0.0)*distance);
+}
+fn traceEnvironmentBase(direction:vec3f)->vec3f{
+ var result=traceParams.background.rgb;
+ if(traceParams.environment.x>=0.0){let local=normalize(mat3x3f(traceParams.environment0.xyz,traceParams.environment1.xyz,traceParams.environment2.xyz)*direction);let uv=vec2f((atan2(local.z,local.x)+3.141592653589793)/6.283185307179586,acos(clamp(local.y,-1.0,1.0))/3.141592653589793);result=surfaceMap(traceParams.environment.x,vec4f(uv,0,0)).rgb*traceParams.environment.y;}
+ return result;
+}
+fn traceEnvironmentAmbient(direction:vec3f)->vec3f{
+ var result=vec3f(0);for(var index=0u;index<u32(traceParams.counts.z);index++){let light=traceLights[index];
+  if(light.position.w==2.0){let weight=dot(direction,normalize(light.position.xyz))*0.5+0.5;result+=mix(light.extra.rgb,light.color.rgb,weight)/3.141592653589793;}
+  else if(light.position.w==3.0){result+=light.color.rgb/3.141592653589793;}
+ }return result;
+}
+fn tracePower(a:f32,b:f32)->f32{return a*a/max(a*a+b*b,1e-30);}
+fn traceEnvironmentPdf(direction:vec3f)->f32{
+ if(traceParams.environment.x<0.0){return 0.0;}let local=normalize(mat3x3f(traceParams.environment0.xyz,traceParams.environment1.xyz,traceParams.environment2.xyz)*direction);let uv=vec2f((atan2(local.z,local.x)+3.141592653589793)/6.283185307179586,acos(clamp(local.y,-1.0,1.0))/3.141592653589793);let column=min(u32(uv.x*traceParams.environment.z),u32(traceParams.environment.z)-1u);let row=min(u32(uv.y*traceParams.environment.w),u32(traceParams.environment.w)-1u);let cell=environmentImportance[row*u32(traceParams.environment.z)+column];return cell.x/(cell.w*max(traceParams.origin.w,1.0));
+}
+fn traceEnvironmentDirect(point:TracePoint,geometric:vec3f,surface:SurfaceValue,view:vec3f,shadowMedia:TraceShadowMedia,continuation:bool,seed:ptr<function,u32>)->vec3f{
+ let position=point.position;
+ if(traceParams.environment.x<0.0){return vec3f(0);}let count=u32(traceParams.environment.z*traceParams.environment.w);let selection=traceRandom(seed)*f32(count);var selected=u32(selection);let proposal=environmentImportance[selected];if(fract(selection)>=proposal.z){selected=u32(proposal.y);}let cell=environmentImportance[selected];let row=selected/u32(traceParams.environment.z);let column=selected%u32(traceParams.environment.z);let phi=((f32(column)+traceRandom(seed))/traceParams.environment.z)*6.283185307179586-3.141592653589793;let cosine=mix(cos(f32(row)*3.141592653589793/traceParams.environment.w),cos(f32(row+1u)*3.141592653589793/traceParams.environment.w),traceRandom(seed));let sine=sqrt(max(0.0,1.0-cosine*cosine));let local=vec3f(sine*cos(phi),cosine,sine*sin(phi));let direction=transpose(mat3x3f(traceParams.environment0.xyz,traceParams.environment1.xyz,traceParams.environment2.xyz))*local;let noL=traceCosine(surface,direction);if(noL<=0.0||!traceValidDirection(geometric,surface,direction)){return vec3f(0);}let hit=occludedSurface(traceOffset(point,geometric,direction),direction,1e20,u32(traceParams.counts.x),u32(traceParams.counts.y),traceRandom(seed));if(hit){return vec3f(0);}let pdf=cell.x/(cell.w*max(traceParams.origin.w,1.0));if(pdf<=0.0){return vec3f(0);}let bsdf=traceEvaluate(surface,view,direction);let brdfPdf=tracePdf(surface,view,direction);return traceShadowBeer(shadowMedia,geometric,direction,1e20)*bsdf*traceEnvironmentBase(direction)*(noL*select(1.0,tracePower(pdf,brdfPdf),continuation)/pdf);
+}
+fn traceEmitterPdf(index:u32,origin:vec3f,position:vec3f)->f32{
+ for(var lightIndex=0u;lightIndex<u32(traceParams.counts.z);lightIndex++){
+  let light=traceLights[lightIndex];if(light.position.w!=4.0||u32(light.position.x)!=index){continue;}
+  let triangle=surfaceTriangle(index);let normal=normalize(cross(triangle.b.xyz-triangle.a.xyz,triangle.c.xyz-triangle.a.xyz));let delta=position-origin;let distance2=dot(delta,delta);let cosine=abs(dot(normal,-normalize(delta)));return light.position.z*distance2/max(light.position.y*cosine*max(traceParams.origin.w,1.0),1e-20);
+ }return 0.0;
+}
+fn traceEmitterDirect(point:TracePoint,geometric:vec3f,surface:SurfaceValue,view:vec3f,shadowMedia:TraceShadowMedia,continuation:bool,seed:ptr<function,u32>)->vec3f{
+ let position=point.position;
+ let selection=traceRandom(seed);var selected:i32=-1;
+ for(var lightIndex=0u;lightIndex<u32(traceParams.counts.z);lightIndex++){let light=traceLights[lightIndex];if(light.position.w==4.0&&selection<=light.extra.x){selected=i32(lightIndex);break;}}
+ if(selected<0){return vec3f(0);}let light=traceLights[u32(selected)];let index=u32(light.position.x);let triangle=surfaceTriangle(index);let root=sqrt(traceRandom(seed));let bary=vec3f(1.0-root,root*(1.0-traceRandom(seed)),0);let weights=vec3f(bary.xy,1.0-bary.x-bary.y);let emitterPoint=triangle.a.xyz*weights.x+triangle.b.xyz*weights.y+triangle.c.xyz*weights.z;
+ let delta=emitterPoint-position;let distance=length(delta);if(distance<=0.002){return vec3f(0);}let direction=delta/distance;let geometricCosine=dot(geometric,direction);let cosine=traceCosine(surface,direction);if(cosine<=0.0||!traceValidDirection(geometric,surface,direction)){return vec3f(0);}
+ let emitNormal=normalize(cross(triangle.b.xyz-triangle.a.xyz,triangle.c.xyz-triangle.a.xyz));let emitCosine=abs(dot(emitNormal,-direction));if(emitCosine<1e-6){return vec3f(0);}let front=surfaceOriginalFront(triangle,dot(emitNormal,-direction)>0.0);let emission=evaluateSurfaceView(index,weights,front,-direction);if(emission.discarded!=0u){return vec3f(0);}
+ let visibility=occludedSurface(traceOffset(point,geometric,direction),direction,distance-.002,u32(traceParams.counts.x),u32(traceParams.counts.y),traceRandom(seed));if(visibility){return vec3f(0);}
+ let pdf=light.position.z*distance*distance/max(light.position.y*emitCosine*max(traceParams.origin.w,1.0),1e-20);let brdfPdf=tracePdf(surface,view,direction);let weight=select(1.0,tracePower(pdf,brdfPdf),continuation);
+ return traceShadowBeer(shadowMedia,geometric,direction,distance)*traceEvaluate(surface,view,direction)*emission.emissive*(cosine*weight*select(1.0,emission.alpha,surfaceMaterials[u32(triangle.a.w)].normal.w==2.0)/pdf);
+}
+fn traceDirect(point:TracePoint,geometric:vec3f,surface:SurfaceValue,view:vec3f,shadowMedia:TraceShadowMedia,continuation:bool,seed:ptr<function,u32>)->vec3f{
+ let position=point.position;
+ let count=u32(traceParams.origin.w);if(count==0u){return vec3f(0);}let selected=min(u32(traceRandom(seed)*f32(count)),count-1u);var current=0u;
+ for(var index=0u;index<u32(traceParams.counts.z);index++){
+  let light=traceLights[index];if(light.position.w>=2.0){continue;}if(current!=selected){current++;continue;}
+  var delta=light.position.xyz;var distance=1e20;var attenuation=1.0;
+  if(light.position.w==0.0){delta-=position;distance=length(delta);if(distance<=0.0001){return vec3f(0);}attenuation=1.0/pow(max(distance,0.01),light.extra.w);if(light.color.w>0.0){let cutoff=clamp(1.0-pow(distance/light.color.w,4.0),0.0,1.0);attenuation*=cutoff*cutoff;}}
+  let direction=normalize(delta);let cosine=traceCosine(surface,direction);if(cosine==0.0||!traceValidDirection(geometric,surface,direction)){return vec3f(0);}
+  if(occludedSurface(traceOffset(point,geometric,direction),direction,distance-.002,u32(traceParams.counts.x),u32(traceParams.counts.y),traceRandom(seed))){return vec3f(0);}
+  return traceShadowBeer(shadowMedia,geometric,direction,distance)*traceEvaluate(surface,view,direction)*light.color.rgb*(cosine*attenuation*f32(count));
+ }
+ if(traceParams.up.w>0.5){if(selected==current){return traceEmitterDirect(point,geometric,surface,view,shadowMedia,continuation,seed);}current++;}
+ if(traceParams.environment.x>=0.0&&selected==current){return traceEnvironmentDirect(point,geometric,surface,view,shadowMedia,continuation,seed);}return vec3f(0);
+}
+@compute @workgroup_size(8,8)
+fn pathMain(@builtin(global_invocation_id) invocation:vec3u){
+ let width=u32(traceParams.screen.x);let height=u32(traceParams.screen.y);if(invocation.x>=width||invocation.y>=height){return;}
+ let index=invocation.y*width+invocation.x;let pixelCount=width*height;
+ var seed=index*1973u+u32(traceParams.screen.z)*9277u+89173u;
+ var radianceSum=vec3f(0);var firstNormal=vec4f(0,0,0,-1);var firstAlbedo=vec4f(0);
+ for(var sample=0u;sample<u32(traceParams.settings.y);sample++){
+  let targeted=traceCaptureFault&&traceVolumeEnabled&&traceParams.environment0.w>=0.0&&index==u32(traceParams.environment0.w)&&f32(sample)==traceParams.environment1.w;
+  if(targeted){traceOutput.pixels[pixelCount*4u+5u]=vec4f(0);traceOutput.pixels[pixelCount*4u+12u]=vec4f(f32(index),traceParams.screen.z,0,f32(sample));}
+  let hybrid=traceParams.flags.x>0.5;
+  var jitter=vec2f(traceRandom(&seed),traceRandom(&seed));if(hybrid){jitter=vec2f(0.5+traceParams.forward.w,0.5+traceParams.right.w);}
+  let pixel=((vec2f(invocation.xy)+jitter)/vec2f(f32(width),f32(height)))*2.0-vec2f(1);
+  var direction=normalize(traceParams.forward.xyz+traceParams.right.xyz*pixel.x-traceParams.up.xyz*pixel.y);
+  var origin=traceParams.origin.xyz+direction*(traceParams.screen.w/max(dot(direction,traceParams.forward.xyz),1e-5));
+  var throughput=vec3f(1);var radiance=vec3f(0);var previousPdf=0.0;var previousDelta=false;var etaScale=1.0;var previousPosition=traceParams.origin.xyz;var media:array<u32,65>;var mediumDepth=1u;media[0]=0u;
+  var previousHit=-1;var previousGeometric=vec3f(0);var previousBary=vec3f(0);var previousEvent=0u;var previousFront=false;
+  if(traceVolumeEnabled){let initialCount=u32(traceParams.medium.y);if(initialCount>64u){atomicAdd(&traceOutput.faults,1u);atomicOr(&traceOutput.faultMask,8u);}else{for(var layer=0u;layer<initialCount;layer++){media[layer+1u]=u32(traceLights[u32(traceParams.medium.z)+layer].position.x);}mediumDepth+=initialCount;}}
+  for(var bounce=0u;bounce<u32(traceParams.settings.z);bounce++){
+   var hit:SurfaceHit;
+   if(hybrid&&bounce==0u){let primary=textureLoad(primaryHits,vec2i(invocation.xy),0);if(primary.y< -1.5){var coverageSeed=seed;let cosine=max(dot(direction,traceParams.forward.xyz),1e-5);let exact=traceSurface(origin,direction,(traceParams.settings.w-traceParams.screen.w)/cosine,u32(traceParams.counts.x),u32(traceParams.counts.y),traceRandom(&coverageSeed));hit=SurfaceHit(exact.distance+traceParams.screen.w/cosine,exact.index,exact.bary,exact.front);}else{hit=SurfaceHit(abs(primary.x),i32(primary.y),vec3f(1.0-primary.z-primary.w,primary.z,primary.w),primary.x>=0.0);}origin=traceParams.origin.xyz;}
+   else{var rayLimit=traceParams.settings.w;if(bounce==0u){rayLimit=(traceParams.settings.w-traceParams.screen.w)/max(dot(direction,traceParams.forward.xyz),1e-5);}hit=traceSurface(origin,direction,rayLimit,u32(traceParams.counts.x),u32(traceParams.counts.y),traceRandom(&seed));}
+   let debugSlot=pixelCount*4u+13u+bounce*8u;
+   if(targeted&&bounce<8u){for(var debugRow=0u;debugRow<8u;debugRow++){traceOutput.pixels[debugSlot+debugRow]=vec4f(0);}traceOutput.pixels[pixelCount*4u+12u].z=f32(bounce+1u);traceOutput.pixels[debugSlot]=vec4f(origin,f32(hit.index));traceOutput.pixels[debugSlot+1u]=vec4f(direction,hit.distance);traceOutput.pixels[debugSlot+2u]=vec4f(f32(mediumDepth),f32(media[mediumDepth-1u]),select(0.0,1.0,hit.front),0);}
+   if(hit.index<0){if(traceVolumeEnabled&&media[mediumDepth-1u]!=0u){let fault=atomicAdd(&traceOutput.faults,1u);if(traceCaptureFault&&((traceParams.environment0.w<0.0&&fault==0u)||targeted)){let tail=pixelCount*4u;traceOutput.pixels[tail]=vec4f(origin,f32(bounce));traceOutput.pixels[tail+1u]=vec4f(direction,f32(media[mediumDepth-1u]));traceOutput.pixels[tail+2u]=vec4f(previousPosition,f32(previousHit));traceOutput.pixels[tail+3u]=vec4f(previousGeometric,f32(previousEvent));traceOutput.pixels[tail+4u]=vec4f(previousBary,f32(index));traceOutput.pixels[tail+5u]=vec4f(select(0.0,1.0,previousFront),traceParams.screen.z,f32(sample),1);if(previousHit>=0){let oldTriangle=surfaceTriangle(u32(previousHit));traceOutput.pixels[tail+6u]=oldTriangle.a;traceOutput.pixels[tail+7u]=oldTriangle.b;traceOutput.pixels[tail+8u]=oldTriangle.c;traceOutput.pixels[tail+9u]=surfaceMaterials[u32(oldTriangle.a.w)].physical;traceOutput.pixels[tail+10u]=oldTriangle.nma;traceOutput.pixels[tail+11u]=oldTriangle.nmb;}}atomicOr(&traceOutput.faultMask,4u);atomicStore(&traceOutput.faultDetail,(mediumDepth<<24u)|media[mediumDepth-1u]);atomicStore(&traceOutput.faultPixel,index);break;}if(bounce==0u){radiance+=throughput*traceParams.background.rgb;}else{let weight=select(1.0,tracePower(previousPdf,traceEnvironmentPdf(direction)),traceParams.flags.z>0.5&&traceParams.environment.x>=0.0&&!previousDelta);radiance+=throughput*(traceEnvironmentBase(direction)*weight+traceEnvironmentAmbient(direction));}break;}
+   let triangle=surfaceTriangle(u32(hit.index));var surface=evaluateSurfaceView(u32(hit.index),hit.bary,hit.front,-direction);let point=tracePoint(triangle,hit.bary);let position=point.position;var shadowMedia=TraceShadowMedia(vec3f(0),vec3f(0));
+   if(traceVolumeEnabled){shadowMedia.incident=traceMediumSigma(media[mediumDepth-1u]);shadowMedia.transmitted=shadowMedia.incident;throughput*=exp(-traceMediumSigma(media[mediumDepth-1u])*length(position-previousPosition));if(surface.medium.x>0.0){let id=u32(triangle.nmb.w);if(id==0u||id>u32(traceParams.medium.w)){atomicAdd(&traceOutput.faults,1u);atomicOr(&traceOutput.faultMask,1u);break;}
+     if(hit.front){var duplicate=false;for(var layer=1u;layer<mediumDepth;layer++){if(media[layer]==id){duplicate=true;}}if(duplicate){atomicAdd(&traceOutput.faults,1u);atomicOr(&traceOutput.faultMask,2u);atomicStore(&traceOutput.faultDetail,(mediumDepth<<24u)|(id<<12u)|media[mediumDepth-1u]);atomicStore(&traceOutput.faultPixel,index);break;}shadowMedia.transmitted=traceMediumSigma(id);surface.medium=vec4f(surface.medium.x,traceMediumIor(media[mediumDepth-1u]),traceMediumIor(id),1.0);}
+     else{if(mediumDepth<2u||media[mediumDepth-1u]!=id){atomicAdd(&traceOutput.faults,1u);atomicOr(&traceOutput.faultMask,2u);atomicStore(&traceOutput.faultDetail,(mediumDepth<<24u)|(id<<12u)|media[mediumDepth-1u]);atomicStore(&traceOutput.faultPixel,index);break;}shadowMedia.transmitted=traceMediumSigma(media[mediumDepth-2u]);surface.medium=vec4f(surface.medium.x,traceMediumIor(media[mediumDepth-2u]),traceMediumIor(id),-1.0);}
+   }}
+   var geometric=normalize(cross(triangle.b.xyz-triangle.a.xyz,triangle.c.xyz-triangle.a.xyz));if(dot(geometric,direction)>0.0){geometric=-geometric;}
+   if(targeted&&bounce<8u){traceOutput.pixels[debugSlot+2u].w=triangle.nmb.w;traceOutput.pixels[debugSlot+3u]=vec4f(position,surface.roughness);traceOutput.pixels[debugSlot+6u]=vec4f(hit.bary,surface.medium.z);traceOutput.pixels[debugSlot+7u]=vec4f(surface.normal,surface.medium.y);}
+   if(sample==0u&&bounce==0u){firstNormal=vec4f(surface.normal,length(position-traceParams.origin.xyz));firstAlbedo=vec4f(surface.base,surface.roughness);}
+   if(bounce==0u&&traceParams.flags.y>0.0){
+    if(traceParams.flags.y==1.0){radiance=surface.base;}
+    else if(traceParams.flags.y==2.0){radiance=surface.normal*0.5+vec3f(0.5);}
+    else if(traceParams.flags.y==3.0){radiance=vec3f(clamp(hit.distance/traceParams.settings.w,0.0,1.0));}
+    break;
+   }
+   var emissionWeight=1.0;if(bounce>0u&&traceParams.flags.z>0.5&&!previousDelta){emissionWeight=tracePower(previousPdf,traceEmitterPdf(u32(hit.index),previousPosition,position));}
+   radiance+=throughput*surface.emissive*emissionWeight;
+   if(traceParams.flags.z>0.5){radiance+=throughput*traceDirect(point,geometric,surface,-direction,shadowMedia,traceParams.flags.w>0.5&&bounce+1u<u32(traceParams.settings.z),&seed);}
+   if(traceParams.flags.w<0.5){break;}
+   let branch=traceRandom(&seed);let random=vec3f(traceRandom(&seed),traceRandom(&seed),traceRandom(&seed));let next=traceScatter(surface,-direction,branch,random);
+   if(targeted&&bounce<8u){traceOutput.pixels[debugSlot+4u]=vec4f(next.direction,f32(next.event));traceOutput.pixels[debugSlot+5u]=vec4f(geometric,next.pdf);}
+   if(next.pdf<=0.0||!traceValidDirection(geometric,surface,next.direction)||(next.event==2u)!=(dot(geometric,next.direction)<0.0)){break;}
+   if(traceVolumeEnabled&&next.event==2u){let id=u32(triangle.nmb.w);if(hit.front){if(mediumDepth>=65u){atomicAdd(&traceOutput.faults,1u);atomicOr(&traceOutput.faultMask,8u);break;}media[mediumDepth]=id;mediumDepth++;}else{mediumDepth--;}etaScale*=next.eta*next.eta;}
+   throughput*=next.weight;previousPdf=next.pdf;previousDelta=next.delta!=0u;
+   if(bounce>=2u&&!previousDelta){let survival=clamp(max(throughput.r,max(throughput.g,throughput.b))*etaScale,0.05,0.95);if(traceRandom(&seed)>survival){break;}throughput/=survival;}
+   if(traceCaptureFault&&traceVolumeEnabled){previousHit=hit.index;previousGeometric=geometric;previousBary=hit.bary;previousEvent=next.event;previousFront=hit.front;}
+   previousPosition=position;origin=traceOffset(point,geometric,next.direction);direction=next.direction;
+  }
+  radianceSum+=radiance;
+ }
+ var old=vec4f(0);if(traceParams.counts.w<0.5){old=traceOutput.pixels[index];}
+ let accumulated=vec4f(old.rgb+radianceSum,old.a+traceParams.settings.y);traceOutput.pixels[index]=accumulated;
+ var average=vec4f(accumulated.rgb/accumulated.a,accumulated.a);if(traceParams.flags.y==4.0){average=vec4f(vec3f(log2(1.0+accumulated.a)/8.0),accumulated.a);}
+ traceOutput.pixels[index+pixelCount]=average;traceOutput.pixels[index+pixelCount*2u]=firstNormal;traceOutput.pixels[index+pixelCount*3u]=firstAlbedo;
+}
+`;
+export const PRIMARY_SHADER = TRACE_PARAMETERS_SHADER +
+    /* wgsl */ String.raw `
+@group(0) @binding(7) var<uniform> primaryParams:TraceParameters;
+struct PrimaryVertex{@builtin(position) position:vec4f,@location(0) @interpolate(flat) index:u32,}
+@vertex fn primaryVertex(@builtin(vertex_index) vertex:u32)->PrimaryVertex{
+ let index=vertex/3u;let corner=vertex%3u;let triangle=surfaceTriangle(index);var world=triangle.a.xyz;if(corner==1u){world=triangle.b.xyz;}if(corner==2u){world=triangle.c.xyz;}
+ let matrix=mat4x4f(primaryParams.view0,primaryParams.view1,primaryParams.view2,primaryParams.view3);return PrimaryVertex(matrix*vec4f(world,1),index);
+}
+@fragment fn primaryFragment(input:PrimaryVertex,@builtin(front_facing) rasterFront:bool)->@location(0) vec4f{
+ let front=surfaceOriginalFront(surfaceTriangle(input.index),rasterFront);
+ let triangle=surfaceTriangle(input.index);
+ // Raster subpixel setup is not precise barycentric data for ray-space motion.
+ let pixel=(input.position.xy+vec2f(primaryParams.forward.w,primaryParams.right.w))/primaryParams.screen.xy*2.0-vec2f(1);
+ let direction=normalize(primaryParams.forward.xyz+primaryParams.right.xyz*pixel.x-primaryParams.up.xyz*pixel.y);
+ let edge1=triangle.b.xyz-triangle.a.xyz;let edge2=triangle.c.xyz-triangle.a.xyz;
+ let p=cross(direction,edge2);let determinant=dot(edge1,p);if(determinant==0.0){return vec4f(0,-2,0,0);}
+ let relative=primaryParams.origin.xyz-triangle.a.xyz;let q=cross(relative,edge1);
+ let u=dot(relative,p)/determinant;let v=dot(direction,q)/determinant;
+ let bary=vec3f(1.0-u-v,u,v);let distance=dot(edge2,q)/determinant;
+ // Hardware raster coverage can select a neighboring face at subpixel edges.
+ // Mark uncertainty for an exact GPU closest-hit query, never clamp into a false boundary.
+ if(any(bary<vec3f(0))||any(bary>vec3f(1))||distance<=0.0||any((bitcast<vec4u>(vec4f(bary,distance))&vec4u(0x7f800000u))==vec4u(0x7f800000u))){return vec4f(0,-2,0,0);}
+ let surface=evaluateSurfaceView(input.index,bary,front,-direction);if(surface.discarded!=0u){discard;}
+ let material=surfaceMaterials[u32(triangle.a.w)];
+ if(material.normal.w==2.0){let threshold=fract(sin(dot(input.position.xy,vec2f(12.9898,78.233))+primaryParams.screen.z)*43758.5453);if(surfaceCoverageRandom(threshold,input.index)>surface.alpha){discard;}}
+ return vec4f(select(-distance,distance,front),f32(input.index),bary.yz);
+}
+`;
+export const TRACE_PRESENT_SHADER = /* wgsl */ String.raw `
+struct Present{size:vec4f,}
+@group(0) @binding(0) var<storage,read> radiance:array<vec4f>;
+@group(0) @binding(1) var<uniform> parameters:Present;
+@vertex fn vertex(@builtin(vertex_index) id:u32)->@builtin(position) vec4f{let points=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));return vec4f(points[id],0,1);}
+fn displaySrgb(value:vec3f)->vec3f{return select(1.055*pow(max(value,vec3f(0)),vec3f(1.0/2.4))-vec3f(0.055),value*12.92,value<=vec3f(0.0031308));}
+@fragment fn fragment(@builtin(position) pixel:vec4f)->@location(0) vec4f{
+ let index=u32(pixel.y)*u32(parameters.size.x)+u32(pixel.x);var color=max(radiance[index].rgb*parameters.size.z,vec3f(0));
+ if(parameters.size.w<0.5){color=clamp((color*(2.51*color+vec3f(0.03)))/(color*(2.43*color+vec3f(0.59))+vec3f(0.14)),vec3f(0),vec3f(1));}
+ return vec4f(displaySrgb(color),1);
+}
+`;
+/** Engine-owned linear HDR handoff. Exposure and display conversion happen in the composer. */
+export const TRACE_LINEAR_PRESENT_SHADER = /* wgsl */ String.raw `
+struct Present{size:vec4f,}
+@group(0) @binding(0) var<storage,read> radiance:array<vec4f>;
+@group(0) @binding(1) var<storage,read> guides:array<vec4f>;
+@group(0) @binding(2) var<uniform> parameters:Present;
+struct Output{@location(0) color:vec4f,@location(1) normal:vec4f,@location(2) depth:vec4f,}
+@vertex fn vertex(@builtin(vertex_index) id:u32)->@builtin(position) vec4f{let points=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));return vec4f(points[id],0,1);}
+@fragment fn fragment(@builtin(position) pixel:vec4f)->Output{
+ let index=u32(pixel.y)*u32(parameters.size.x)+u32(pixel.x);
+ let guide=guides[index];let hit=select(0.0,1.0,guide.w>=0.0);
+ return Output(vec4f(max(radiance[index].rgb,vec3f(0)),1),vec4f(guide.xyz,hit),vec4f(max(guide.w,0.0),0,0,hit));
+}
+`;

package/lib/renderer/pathtrace.js

@@ -0,0 +1,324 @@
+const shader = /* wgsl */ `
+struct Triangle { a: vec4f, b: vec4f, c: vec4f, color: vec4f, pad: vec4f }
+struct Node { lo: vec4f, hi: vec4f }
+struct Params { origin: vec4f, forward: vec4f, right: vec4f, up: vec4f, screen: vec4f, settings: vec4f, lightPosition:vec4f, lightColor:vec4f, environment:vec4f }
+@group(0) @binding(0) var<storage,read> triangles: array<Triangle>;
+@group(0) @binding(1) var<storage,read> nodes: array<Node>;
+@group(0) @binding(2) var<uniform> params: Params;
+@group(0) @binding(3) var image: texture_storage_2d<rgba8unorm,write>;
+@group(0) @binding(4) var<storage,read_write> history: array<vec4f>;
+@group(0) @binding(5) var<storage,read_write> queryResult: array<vec4f>;
+struct Hit { t: f32, index: i32, normal: vec3f }
+fn random(seed: ptr<function,u32>) -> f32 { *seed = *seed * 1664525u + 1013904223u; var x = *seed; x = ((x >> 16u) ^ x) * 2246822519u; return f32(x >> 8u) / 16777216.0; }
+fn boxHit(o: vec3f, d: vec3f, node: Node, maxT: f32) -> bool {
+ let inverse = 1.0 / (d + vec3f(1e-12));
+ let a = (node.lo.xyz - o) * inverse; let b = (node.hi.xyz - o) * inverse;
+ let low = min(a,b); let high = max(a,b);
+ return max(max(low.x,low.y),max(low.z,0.0)) <= min(min(high.x,high.y),min(high.z,maxT));
+}
+fn trace(o: vec3f,d: vec3f,maxT: f32) -> Hit {
+ var result = Hit(maxT,-1,vec3f(0));
+ var stack: array<u32,64>; stack[0] = 0u; var size = 1u;
+ loop {
+  if size == 0u { break; } size -= 1u; let node = nodes[stack[size]];
+  if !boxHit(o,d,node,result.t) { continue; }
+  if node.hi.w > 0.0 {
+   let start = u32(node.lo.w); let count = u32(node.hi.w);
+   for(var j=0u;j<count;j++) {
+    let id = start+j; let t = triangles[id]; let edge1 = t.b.xyz-t.a.xyz; let edge2 = t.c.xyz-t.a.xyz;
+    let p = cross(d,edge2); let det = dot(edge1,p); if abs(det)<1e-7 { continue; }
+    let inv = 1.0/det; let s = o-t.a.xyz; let u = dot(s,p)*inv; if u<0.0 || u>1.0 { continue; }
+    let q = cross(s,edge1); let v = dot(d,q)*inv; if v<0.0 || u+v>1.0 { continue; }
+    let distance = dot(edge2,q)*inv;
+    if distance>0.001 && distance<result.t { var n = normalize(cross(edge1,edge2)); if dot(n,d)>0.0 { n = -n; } result = Hit(distance,i32(id),n); }
+   }
+  } else if size < 62u { stack[size] = u32(node.lo.w); stack[size+1u] = u32(-node.hi.w); size += 2u; }
+ }
+ return result;
+}
+fn hemisphere(n: vec3f, seed: ptr<function,u32>) -> vec3f {
+ let u = random(seed); let phi = 6.2831853*random(seed); let r = sqrt(u);
+ let tangent = normalize(cross(n,select(vec3f(0,1,0),vec3f(1,0,0),abs(n.y)>0.9)));
+ return normalize(tangent*(r*cos(phi))+cross(n,tangent)*(r*sin(phi))+n*sqrt(1.0-u));
+}
+@compute @workgroup_size(1)
+fn queryRay() { let hit=trace(params.origin.xyz,normalize(params.forward.xyz),1e20);queryResult[0]=vec4f(hit.t,f32(hit.index),0,0);queryResult[1]=vec4f(hit.normal,0); }
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+ let width = u32(params.screen.x); let height = u32(params.screen.y); if id.x>=width || id.y>=height { return; }
+ let index = id.y*width+id.x; var seed = index*1973u+u32(params.screen.z)*9277u+89173u;
+ let jitter = vec2f(random(&seed),random(&seed));
+ let pixel = ((vec2f(id.xy)+jitter)/vec2f(f32(width),f32(height))*2.0-1.0);
+ var origin = params.origin.xyz;
+ var direction = normalize(params.forward.xyz+params.right.xyz*pixel.x-params.up.xyz*pixel.y);
+ origin += direction*params.settings.z;
+ var throughput = vec3f(1); var radiance = vec3f(0);
+ for(var bounce=0u;bounce<u32(params.settings.x);bounce++) {
+  let hit = trace(origin,direction,params.screen.w);
+  if hit.index<0 { radiance += throughput*params.environment.rgb*(0.2+max(direction.y,0.0))*params.environment.w; break; }
+  let triangle = triangles[u32(hit.index)]; let position = origin+direction*hit.t;
+  radiance += throughput*triangle.color.rgb*triangle.a.w;
+  let light = params.lightPosition.xyz+vec3f(random(&seed)-0.5,0,random(&seed)-0.5)*select(1.2,0.0,params.lightColor.w>0.5);
+  let toLight = select(light-position,light,params.lightColor.w>0.5); let distance = select(length(toLight),1e10,params.lightColor.w>0.5); let l = normalize(toLight);
+  if trace(position+hit.normal*0.003,l,distance-0.02).index<0 { radiance += throughput*triangle.color.rgb*params.lightColor.rgb*max(dot(hit.normal,l),0.0)*params.lightPosition.w/select(distance*distance,1.0,params.lightColor.w>0.5); }
+  let diffuse = hemisphere(hit.normal,&seed); let reflected = reflect(direction,hit.normal);
+  direction = normalize(mix(reflected,diffuse,triangle.b.w));
+  throughput *= triangle.color.rgb; origin = position+hit.normal*0.003;
+  if bounce>2u { let survival = min(max(max(throughput.r,throughput.g),throughput.b),0.95); if random(&seed)>survival { break; } throughput /= survival; }
+ }
+ let old = select(vec4f(0),history[index],params.settings.y>0.5); let accumulated = vec4f(old.rgb+radiance,old.a+1.0); history[index] = accumulated;
+ let linear = accumulated.rgb/accumulated.a; let mapped = pow(linear/(linear+vec3f(1)),vec3f(1.0/2.2));
+ textureStore(image,vec2i(id.xy),vec4f(mapped,1));
+}
+`;
+const present = /* wgsl */ `
+@group(0) @binding(0) var image: texture_2d<f32>;
+@vertex fn vs(@builtin(vertex_index) i:u32)->@builtin(position) vec4f { let p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3)); return vec4f(p[i],0,1); }
+@fragment fn fs(@builtin(position) p:vec4f)->@location(0) vec4f { return textureLoad(image,vec2i(p.xy),0); }
+`;
+/** Internal M0 software triangle-BVH tracer. No hardware RT/production quality claim. */
+export class GPUTracer {
+    device;
+    context;
+    compute;
+    render;
+    query;
+    uniform;
+    history;
+    output;
+    triangleBuffer;
+    nodeBuffer;
+    computeGroup;
+    presentGroup;
+    timestamps;
+    timestampResult;
+    frame = 0;
+    width;
+    height;
+    constructor(device, canvas, width, height) {
+        this.device = device;
+        this.width = width;
+        this.height = height;
+        if (device.features.has("timestamp-query")) {
+            this.timestamps = device.createQuerySet({ type: "timestamp", count: 2 });
+            this.timestampResult = device.createBuffer({
+                size: 256,
+                usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
+            });
+        }
+        canvas.width = width;
+        canvas.height = height;
+        this.context = canvas.getContext("webgpu");
+        const format = navigator.gpu.getPreferredCanvasFormat();
+        this.context.configure({ device, format, alphaMode: "opaque" });
+        const tracerModule = device.createShaderModule({ code: shader });
+        this.compute = device.createComputePipeline({
+            layout: "auto",
+            compute: { module: tracerModule, entryPoint: "main" },
+        });
+        this.query = device.createComputePipeline({
+            layout: "auto",
+            compute: { module: tracerModule, entryPoint: "queryRay" },
+        });
+        const module = device.createShaderModule({ code: present });
+        this.render = device.createRenderPipeline({
+            layout: "auto",
+            vertex: { module, entryPoint: "vs" },
+            fragment: { module, entryPoint: "fs", targets: [{ format }] },
+            primitive: { topology: "triangle-list" },
+        });
+        this.uniform = device.createBuffer({
+            size: 144,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this.history = device.createBuffer({
+            size: width * height * 16,
+            usage: GPUBufferUsage.STORAGE,
+        });
+        this.output = device.createTexture({
+            size: [width, height],
+            format: "rgba8unorm",
+            usage: GPUTextureUsage.STORAGE_BINDING |
+                GPUTextureUsage.TEXTURE_BINDING |
+                GPUTextureUsage.COPY_SRC,
+        });
+        this.presentGroup = device.createBindGroup({
+            layout: this.render.getBindGroupLayout(0),
+            entries: [{ binding: 0, resource: this.output.createView() }],
+        });
+    }
+    upload(geometry) {
+        this.triangleBuffer?.destroy();
+        this.nodeBuffer?.destroy();
+        const upload = (data) => {
+            const buffer = this.device.createBuffer({
+                size: data.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+            this.device.queue.writeBuffer(buffer, 0, data.buffer, data.byteOffset, data.byteLength);
+            return buffer;
+        };
+        this.triangleBuffer = upload(geometry.triangles);
+        this.nodeBuffer = upload(geometry.nodes);
+        this.computeGroup = this.device.createBindGroup({
+            layout: this.compute.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: this.triangleBuffer } },
+                { binding: 1, resource: { buffer: this.nodeBuffer } },
+                { binding: 2, resource: { buffer: this.uniform } },
+                { binding: 3, resource: this.output.createView() },
+                { binding: 4, resource: { buffer: this.history } },
+            ],
+        });
+    }
+    renderFrame(camera, mode, accumulate) {
+        const start = performance.now();
+        const vec = (v) => [...v, 0];
+        const data = new Float32Array([
+            ...vec(camera.origin),
+            ...vec(camera.forward),
+            ...vec(camera.right),
+            ...vec(camera.up),
+            this.width,
+            this.height,
+            this.frame++,
+            camera.far,
+            mode === "path" ? 5 : 2,
+            accumulate ? 1 : 0,
+            camera.near,
+            0,
+            ...camera.light.position,
+            camera.light.intensity,
+            ...camera.light.color,
+            camera.light.directional ? 1 : 0,
+            ...camera.environment,
+            camera.ambient,
+        ]);
+        this.device.queue.writeBuffer(this.uniform, 0, data);
+        const encoder = this.device.createCommandEncoder();
+        const compute = encoder.beginComputePass(this.timestamps
+            ? {
+                timestampWrites: {
+                    querySet: this.timestamps,
+                    beginningOfPassWriteIndex: 0,
+                    endOfPassWriteIndex: 1,
+                },
+            }
+            : {});
+        compute.setPipeline(this.compute);
+        compute.setBindGroup(0, this.computeGroup);
+        compute.dispatchWorkgroups(Math.ceil(this.width / 8), Math.ceil(this.height / 8));
+        compute.end();
+        if (this.timestamps)
+            encoder.resolveQuerySet(this.timestamps, 0, 2, this.timestampResult, 0);
+        const render = encoder.beginRenderPass({
+            colorAttachments: [
+                {
+                    view: this.context.getCurrentTexture().createView(),
+                    loadOp: "clear",
+                    storeOp: "store",
+                    clearValue: { r: 0, g: 0, b: 0, a: 1 },
+                },
+            ],
+        });
+        render.setPipeline(this.render);
+        render.setBindGroup(0, this.presentGroup);
+        render.draw(3);
+        render.end();
+        this.device.queue.submit([encoder.finish()]);
+        return performance.now() - start;
+    }
+    async queryRay(origin, direction) {
+        const output = this.device.createBuffer({
+            size: 32,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+        });
+        const read = this.device.createBuffer({
+            size: 32,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        });
+        const values = new Float32Array(36);
+        values.set(origin, 0);
+        values.set(direction, 4);
+        this.device.queue.writeBuffer(this.uniform, 0, values);
+        const group = this.device.createBindGroup({
+            layout: this.query.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: this.triangleBuffer } },
+                { binding: 1, resource: { buffer: this.nodeBuffer } },
+                { binding: 2, resource: { buffer: this.uniform } },
+                { binding: 5, resource: { buffer: output } },
+            ],
+        });
+        const encoder = this.device.createCommandEncoder();
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(this.query);
+        pass.setBindGroup(0, group);
+        pass.dispatchWorkgroups(1);
+        pass.end();
+        encoder.copyBufferToBuffer(output, 0, read, 0, 32);
+        this.device.queue.submit([encoder.finish()]);
+        await read.mapAsync(GPUMapMode.READ);
+        const result = Array.from(new Float32Array(read.getMappedRange()));
+        read.unmap();
+        output.destroy();
+        read.destroy();
+        return {
+            distance: result[0],
+            triangle: result[1],
+            normal: result.slice(4, 7),
+        };
+    }
+    async gpuTimeMs() {
+        if (!this.timestampResult)
+            return null;
+        const buffer = this.device.createBuffer({
+            size: 16,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        });
+        const encoder = this.device.createCommandEncoder();
+        encoder.copyBufferToBuffer(this.timestampResult, 0, buffer, 0, 16);
+        this.device.queue.submit([encoder.finish()]);
+        await buffer.mapAsync(GPUMapMode.READ);
+        const values = new BigUint64Array(buffer.getMappedRange());
+        const ms = Number(values[1] - values[0]) / 1e6;
+        buffer.unmap();
+        buffer.destroy();
+        return ms;
+    }
+    async pixelStats() {
+        const bytesPerRow = Math.ceil((this.width * 4) / 256) * 256;
+        const buffer = this.device.createBuffer({
+            size: bytesPerRow * this.height,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        });
+        const encoder = this.device.createCommandEncoder();
+        encoder.copyTextureToBuffer({ texture: this.output }, { buffer, bytesPerRow }, { width: this.width, height: this.height });
+        this.device.queue.submit([encoder.finish()]);
+        await buffer.mapAsync(GPUMapMode.READ);
+        const bytes = new Uint8Array(buffer.getMappedRange());
+        let sum = 0, nonBlack = 0, hash = 2166136261;
+        for (let y = 0; y < this.height; y += 4)
+            for (let x = 0; x < this.width; x += 4) {
+                const i = y * bytesPerRow + x * 4;
+                const value = bytes[i] + bytes[i + 1] + bytes[i + 2];
+                sum += value;
+                if (value > 15)
+                    nonBlack++;
+                hash = Math.imul(hash ^ value, 16777619);
+            }
+        buffer.unmap();
+        buffer.destroy();
+        return { sum, nonBlack, hash: hash >>> 0 };
+    }
+    dispose() {
+        this.triangleBuffer?.destroy();
+        this.nodeBuffer?.destroy();
+        this.uniform.destroy();
+        this.history.destroy();
+        this.output.destroy();
+        this.context.unconfigure();
+        this.timestamps?.destroy();
+        this.timestampResult?.destroy();
+    }
+}

package/lib/renderer/postprocess-contract.js

@@ -0,0 +1 @@
+export {};