Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

14.1 KB
Raw Blame
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { readFile } from 'node:fs/promises';
import { dirname, join } from 'node:path';
import { createRequire } from 'node:module';
import { fileURLToPath } from 'node:url';
import { chromium } from 'playwright-core';
import { startOwnedBrowserFixture } from '../../../../test/browserFixture.js';
import { browserSuiteCanRun, resolveTestChrome } from '../../../../lib/browserSuiteGate.js';

const require = createRequire(import.meta.url);
const chrome = resolveTestChrome();
const canRun = browserSuiteCanRun('toon world browser', { Chrome: chrome });
const root = dirname(fileURLToPath(import.meta.url));
const threeRoot = dirname(require.resolve('three'));

describe.skipIf(!canRun)('toon world headless dish proof', () => {
  let browser, browserFixture, page;
  const errors = [];
  beforeAll(async () => {
    browserFixture = await startOwnedBrowserFixture({ chromium, launchOptions: { executablePath: chrome, headless: true,
      args: ['--mute-audio', '--use-angle=swiftshader', '--enable-unsafe-swiftshader',
        '--disable-frame-rate-limit', '--disable-background-timer-throttling', '--disable-renderer-backgrounding'] } });
    browser = browserFixture.browser;
    page = await browser.newPage({ viewport: { width: 640, height: 360 } });
    page.on('pageerror', error => errors.push(error.message));
    page.on('console', message => { if (message.type() === 'error') errors.push(message.text()); });
    await page.route('http://toon.test/**', async route => {
      const name = new URL(route.request().url()).pathname.slice(1);
      if (name === '') return route.fulfill({ contentType: 'text/html', body: '<canvas id="world"></canvas><script type="module" src="fixture.js"></script>' });
      if (name === 'fixture.js') return route.fulfill({ contentType: 'text/javascript', body: fixture });
      const files = { 'toonWorld.js': join(root, 'toonWorld.js'), 'engine.js': join(root, '../spatial/engine.js'),
        'vendor/three.module.js': join(threeRoot, 'three.module.js'), 'vendor/three.core.js': join(threeRoot, 'three.core.js') };
      if (!files[name]) return route.abort();
      return route.fulfill({ contentType: 'text/javascript', body: await readFile(files[name]) });
    });
    await page.goto('http://toon.test/');
    await page.waitForFunction(() => window.proof);
  }, 30000);
  afterAll(async () => { await browserFixture?.close(); });

  it('renders thick, separated dishes and refuses hidden ink with optical passes on/off', async () => {
    const results = await page.evaluate(() => window.proof());
    expect(results.overlaps).toEqual([]);
    expect(results.inkChanged).toBeGreaterThan(300);
    expect(results.hiddenChanged).toBe(0);
    expect(results.flatChanged).toBe(0);
    expect(new Set(results.views).size).toBe(3);
    expect(results.postChanged).toBeGreaterThan(1000);
    expect(results.darkInkCount).toBeGreaterThan(100);
    expect(results.bloomOverInk).toBe(0);
    expect(results.repeat).toBe(true);
    expect(errors).toEqual([]);
    if (process.env.PORTOS_TOON_PROOF_IMAGE) await page.screenshot({ path: process.env.PORTOS_TOON_PROOF_IMAGE });
  }, 60000);

  it('keeps ink within twice the completed baseline cost and reports each measured boundary', async () => {
    const results = await page.evaluate(() => window.costProof());
    const diagnostics = reportCost('ink', results);
    // SwiftShader (forced above) rasterises the extra full-screen ink pass in software, so CI Linux measures ~1.6x
    // where a hardware GPU stays near 1.5x. Retain the original completed-frame budget.
    expect(results.ratio, diagnostics).toBeLessThanOrEqual(2);
    for (const sample of results.samples) {
      expect(sample.scenePasses, diagnostics).toBe(1);
      expect(sample.screenPasses, diagnostics).toBe(sample.ink ? 1 : 0);
    }
    expect(errors).toEqual([]);
  }, 60000);

  it('rejects actual duplicated renderer work with the same 2x cost budget', async () => {
    // Execute three complete ink frames before one readback: this is real GPU work,
    // not multiplied timings or a fabricated slow sample.
    const results = await page.evaluate(() => window.costProof(3));
    const diagnostics = reportCost('duplicated-ink', results);
    for (const sample of results.samples.filter(sample => sample.ink)) {
      expect(sample.scenePasses, diagnostics).toBe(3);
      expect(sample.screenPasses, diagnostics).toBe(3);
    }
    expect(results.ratio, diagnostics).toBeGreaterThan(2);
    expect(errors).toEqual([]);
  }, 60000);

  it('selects all three explicit palette colors from illumination before receiving shadows', async () => {
    const colors = await page.evaluate(() => window.paletteProof());
    for (const [i, expected] of [[87, 69, 111], [186, 129, 123], [246, 206, 134]].entries()) {
      for (let channel = 0; channel < 3; channel++) expect(Math.abs(colors[i][channel] - expected[channel])).toBeLessThanOrEqual(1);
    }
    expect(errors).toEqual([]);
  });

  it('supports a manual/layered post stack and restores the caller target', async () => {
    const result = await page.evaluate(() => window.manualProof());
    expect(result.changed).toHaveLength(2);
    for (const count of result.changed) expect(count).toBeGreaterThan(300);
    expect(result.restored).toBe(true);
    expect(result.feedbackRefused).toBe(true);
    expect(errors).toEqual([]);
  });
});

function reportCost(label, results) {
  const lines = [`🎨 Toon ${label}: baseline ${results.baselineMs.toFixed(2)}ms, ink ${results.inkMs.toFixed(2)}ms, ratio ${results.ratio.toFixed(3)}`];
  for (const [index, sample] of results.samples.entries()) {
    lines.push(`🎨 Toon ${label} sample ${index}: ink=${sample.ink} submit=${sample.submitMs.toFixed(2)}ms readback=${sample.readbackMs.toFixed(2)}ms total=${sample.totalMs.toFixed(2)}ms scene=${sample.scenePasses} screen=${sample.screenPasses} draws=${sample.drawCalls} triangles=${sample.triangles}`);
  }
  for (const [index, sample] of results.completionSamples.entries()) {
    lines.push(`🎨 Toon ${label} completion ${index}: ink=${sample.ink} submit=${sample.submitMs.toFixed(2)}ms finish=${sample.finishMs.toFixed(2)}ms readback=${sample.readbackMs.toFixed(2)}ms`);
  }
  // CI silences console methods: retain the summary and attach all bounded
  // samples to failed assertions so the first failed run remains diagnosable.
  process.stdout.write(`${lines[0]}\n`);
  for (const line of lines.slice(1)) console.log(line);
  return lines.join('\n');
}

const fixture = `
import * as THREE from './vendor/three.module.js';
import * as kit from './toonWorld.js';
import { createPost } from './engine.js';
const renderer = new THREE.WebGLRenderer({canvas:document.getElementById('world'),preserveDrawingBuffer:true});
renderer.setSize(640,360,false); renderer.shadowMap.enabled=true;
const post=createPost(THREE,renderer);post.resize(640,360);
const scene=new THREE.Scene();scene.background=new THREE.Color('#65556e');
const camera=new THREE.PerspectiveCamera(40,640/360,.1,100);
camera.position.set(9,8,17);camera.lookAt(0,1,0);
const sun=new THREE.DirectionalLight('#ffe2ad',2);sun.position.set(-7,8,4);sun.castShadow=true;
sun.shadow.mapSize.set(512,512);sun.shadow.camera.left=-14;sun.shadow.camera.right=14;
sun.shadow.camera.top=10;sun.shadow.camera.bottom=-10;scene.add(sun);
scene.add(new THREE.AmbientLight('#927fa5',.15));
const material=kit.toonMaterial(THREE,{lit:'#f6d89e',mid:'#b98c88',shadow:'#65518b'});
const profile=Array.from({length:25},(_,i)=>[i/24,(i/24)**2*.6]);
const dishes=kit.layoutRow({count:7,footprint:2.3,gap:.5,curve:x=>Math.cos(x*.2)}).map(p=>{
  const dish=new THREE.Mesh(kit.shellLathe(profile,.12,64),material);
  dish.position.set(p.x,1.2,p.z);dish.castShadow=true;dish.receiveShadow=true;scene.add(dish);
  const stand=new THREE.Mesh(new THREE.CylinderGeometry(.1,.16,1.2,12),material);
  stand.position.set(p.x,.6,p.z);stand.castShadow=true;scene.add(stand);return dish;
});
const ground=new THREE.Mesh(new THREE.PlaneGeometry(80,80),kit.toonMaterial(THREE,{lit:'#cf987b',mid:'#a57280',shadow:'#58436a'}));
ground.rotation.x=-Math.PI/2;ground.receiveShadow=true;scene.add(ground);
const pixels=()=>{const gl=renderer.getContext(),p=new Uint8Array(640*360*4);gl.readPixels(0,0,640,360,gl.RGBA,gl.UNSIGNED_BYTE,p);return p;};
const changed=(a,b,region=()=>true)=>{let count=0;for(let i=0;i<a.length;i+=4)if(region(i/4)&&a.slice(i,i+3).some((v,j)=>Math.abs(v-b[i+j])>3))count++;return count;};
const draw=(lens={})=>{post.render(scene,camera,lens,0);renderer.getContext().finish();return pixels();};
window.paletteProof=()=>{
  const world=new THREE.Scene(),view=new THREE.OrthographicCamera(-1,1,1,-1,.1,10);
  view.position.z=3;
  const mat=kit.toonMaterial(THREE),geometry=new THREE.PlaneGeometry(2,2);
  world.add(new THREE.Mesh(geometry,mat));
  const light=new THREE.DirectionalLight('#ffffff',1);world.add(light);
  const colors=[];
  for(const dot of [.1,.5,.9]){
    light.position.set(Math.sqrt(1-dot*dot),0,dot);
    renderer.setRenderTarget(null);renderer.render(world,view);
    const p=pixels(),center=(180*640+320)*4;colors.push([...p.slice(center,center+3)]);
  }
  mat.dispose();geometry.dispose();
  return colors;
};
window.manualProof=()=>{
  const input=new THREE.WebGLRenderTarget(640,360,{type:THREE.HalfFloatType,depthTexture:new THREE.DepthTexture(640,360,THREE.FloatType)});
  const output=new THREE.WebGLRenderTarget(640,360,{depthBuffer:false});
  const ink=kit.createInkPass(THREE,renderer);
  const ortho=new THREE.OrthographicCamera(-12,12,6.75,-6.75,.1,100);
  ortho.position.copy(camera.position);ortho.lookAt(0,1,0);
  const read=()=>{const p=new Uint8Array(640*360*4);renderer.readRenderTargetPixels(output,0,0,640,360,p);return p;};
  const changes=[];let restored=true;
  for(const view of [camera,ortho]){
    renderer.setRenderTarget(input);renderer.render(scene,view);
    ink.render(input,view,output,{enabled:false});const baseline=read();
    ink.render(input,view,output);const outlined=read();
    changes.push(changed(baseline,outlined));restored&&=renderer.getRenderTarget()===input;
  }
  let feedbackRefused=false;try{ink.render(input,camera,input);}catch{feedbackRefused=true;}
  renderer.setRenderTarget(null);ink.dispose();input.dispose();output.dispose();
  return {changed:changes,restored,feedbackRefused};
};
window.proof=()=>{
  const baseline=draw(), ink=draw({ink:true});
  const inkChanged=changed(baseline,ink);
  const blackInk=draw({ink:{color:'#000000',width:2}});
  const bloomedInk=draw({ink:{color:'#000000',width:2},bloom:4,bloomThreshold:0});
  let darkInkCount=0,bloomOverInk=0;
  for(let i=0;i<blackInk.length;i+=4){
    if(blackInk.slice(i,i+3).every(v=>v<3)&&baseline.slice(i,i+3).some(v=>v>50)){
      darkInkCount++;if(bloomedInk.slice(i,i+3).some(v=>v>3))bloomOverInk++;
    }
  }
  // Empty ground in the lower left has no silhouette or crease.
  const flatChanged=changed(baseline,ink,index=>{const x=index%640,y=Math.floor(index/640);return x>30&&x<100&&y>30&&y<100;});
  const views=[];
  for(const p of [[9,8,17],[8,.7,14],[0,2,19]]){camera.position.set(...p);camera.lookAt(0,1.2,0);draw({ink:true});views.push(document.getElementById('world').toDataURL());}
  camera.position.set(9,8,17);camera.lookAt(0,1,0);
  const before=draw({ink:true});
  const withPost=draw({ink:true,aperture:6,focus:10,maxBlur:8,bloom:.3,bloomThreshold:.2,exposure:1.1,grain:.03});
  const postChanged=changed(before,withPost);
  const repeat=changed(withPost,draw({ink:true,aperture:6,focus:10,maxBlur:8,bloom:.3,bloomThreshold:.2,exposure:1.1,grain:.03}))===0;
  // A solid flat blocker fills the central screen; dishes remain behind it.
  const blocker=new THREE.Mesh(new THREE.PlaneGeometry(8,8),new THREE.MeshBasicMaterial({color:'#63aa85'}));
  blocker.position.copy(camera.position).multiplyScalar(.65);blocker.lookAt(camera.position);scene.add(blocker);
  const noInk=draw(), yesInk=draw({ink:true});
  const hiddenChanged=changed(noInk,yesInk,index=>{const x=index%640,y=Math.floor(index/640);return x>260&&x<380&&y>130&&y<230;});
  scene.remove(blocker);
  return {overlaps:kit.warnOverlaps(THREE,dishes),darkInkCount,bloomOverInk,inkChanged,hiddenChanged,flatChanged,views,postChanged,repeat};
};
window.costProof=(inkFrames=1)=>{
  // Keep synchronous readPixels inside the original 15-sample total-cost window.
  // Submission includes CPU/driver time; readback includes pending GPU work and
  // scheduling. Neither is a GPU timer or proof of contention by itself.
  for(let i=0;i<4;i++){draw();draw({ink:true});}
  const samples=[],completionSamples=[];
  const originalRender=renderer.render,autoReset=renderer.info.autoReset;
  let scenePasses=0,screenPasses=0;
  renderer.render=function(world,view){
    if(world===scene)scenePasses++;else screenPasses++;
    return originalRender.call(this,world,view);
  };
  renderer.info.autoReset=false;
  const measure=(enabled,complete=false)=>{
    scenePasses=0;screenPasses=0;renderer.info.reset();
    const start=performance.now();
    for(let pass=0;pass<(enabled?inkFrames:1);pass++)post.render(scene,camera,enabled?{ink:true}:{},0);
    const submitted=performance.now();
    if(complete)renderer.getContext().finish();
    const finished=complete?performance.now():submitted;
    pixels();
    const end=performance.now();
    return {ink:enabled,submitMs:submitted-start,finishMs:finished-submitted,readbackMs:end-finished,totalMs:end-start,
      scenePasses,screenPasses,drawCalls:renderer.info.render.calls,triangles:renderer.info.render.triangles};
  };
  try{
    for(let i=0;i<15;i++){
      for(const enabled of (i%2?[true,false]:[false,true]))samples.push(measure(enabled));
    }
    // Separate diagnostic probes drain GPU work before readback. They alter the
    // synchronization boundary, so never substitute them into the 2x assertion.
    for(let i=0;i<3;i++)for(const enabled of [false,true])completionSamples.push(measure(enabled,true));
  }finally{
    renderer.render=originalRender;renderer.info.autoReset=autoReset;
  }
  const median=values=>values.sort((x,y)=>x-y)[Math.floor(values.length/2)];
  const baselineMs=median(samples.filter(s=>!s.ink).map(s=>s.totalMs));
  const inkMs=median(samples.filter(s=>s.ink).map(s=>s.totalMs));
  return {baselineMs,inkMs,ratio:inkMs/baselineMs,samples,completionSamples};
};
`;