3D engine that AI agents drive
JavaScript 3d3d-engineagentic-aiai-agentsblenderclaude-codegame-enginegaussian-splattinggltfjavascriptmcpmcp-servermodel-context-protocolpath-tracerpath-tracingpbrrenderingthreejs-alternativewebgl2webgpu
import assert from 'node:assert/strict';
import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { test } from 'node:test';
import {
SHADER_CACHE_PROFILE_FOLDER, folderBytes, isWriteLocked, launchWithShaderCache, saveShaderCache, seedShaderCache, shaderCacheDirectory,
} from '../scripts/agent-shader-cache.mjs';
function makeFolder() {
return mkdtempSync(join(tmpdir(), 'crucible-shader-cache-test-'));
}
function writeCache(root, files) {
const folder = join(root, SHADER_CACHE_PROFILE_FOLDER);
mkdirSync(folder, { recursive: true });
for (const [name, text] of Object.entries(files)) writeFileSync(join(folder, name), text);
return folder;
}
function readCache(root) {
const folder = join(root, SHADER_CACHE_PROFILE_FOLDER);
return Object.fromEntries(readdirSync(folder).map(name => [name, readFileSync(join(folder, name), 'utf8')]));
}
test('the cache folder follows the platform, an absolute override, and the off switch', () => {
assert.equal(shaderCacheDirectory({ LOCALAPPDATA: 'C:\\Local' }, 'win32'), join('C:\\Local', 'crucible', 'shader-cache'));
assert.equal(shaderCacheDirectory({ XDG_CACHE_HOME: '/xdg' }, 'linux'), join('/xdg', 'crucible', 'shader-cache'));
assert.match(shaderCacheDirectory({}, 'linux'), /\.cache[\\/]crucible[\\/]shader-cache$/);
assert.equal(shaderCacheDirectory({ CRUCIBLE_SHADER_CACHE: join(tmpdir(), 'mine') }, 'linux'), join(tmpdir(), 'mine'));
assert.equal(shaderCacheDirectory({ SIXTYSEVENJS_SHADER_CACHE: join(tmpdir(), 'legacy') }, 'linux'), join(tmpdir(), 'legacy'));
});
test('CRUCIBLE_SHADER_CACHE=0 or off turns the cache off, and a relative folder says what to pass', () => {
assert.equal(shaderCacheDirectory({ CRUCIBLE_SHADER_CACHE: '0' }), null);
assert.equal(shaderCacheDirectory({ CRUCIBLE_SHADER_CACHE: 'off' }), null);
assert.throws(() => shaderCacheDirectory({ CRUCIBLE_SHADER_CACHE: 'cache' }), /absolute folder, "0" or "off", got "cache"/);
});
test('seeding copies only the GPUCache folder into the profile', () => {
const cache = makeFolder();
const profile = makeFolder();
writeCache(cache, { data_0: 'compiled' });
writeFileSync(join(cache, 'cookies'), 'not a shader');
assert.equal(seedShaderCache(cache, profile), 'seeded');
assert.deepEqual(readCache(profile), { data_0: 'compiled' });
assert.deepEqual(readdirSync(profile), ['Default']);
assert.equal(seedShaderCache(makeFolder(), makeFolder()), 'empty');
});
test('saving copies only the GPUCache folder, replaces the old cache and leaves no temporary folders', () => {
const cache = makeFolder();
const profile = makeFolder();
writeCache(cache, { old: 'old' });
writeCache(profile, { fresh: 'fresh' });
mkdirSync(join(profile, 'Default', 'Local Storage'), { recursive: true });
writeFileSync(join(profile, 'Default', 'Cookies'), 'secret');
assert.equal(saveShaderCache(cache, profile), 'saved');
assert.deepEqual(readCache(cache), { fresh: 'fresh' });
assert.deepEqual(readdirSync(join(cache, 'Default')), ['GPUCache']);
assert.deepEqual(readdirSync(cache), ['Default']);
assert.equal(saveShaderCache(cache, makeFolder()), 'nothing');
});
test('a cache over the size cap is dropped instead of grown, on save and on seed', () => {
const cache = makeFolder();
const profile = makeFolder();
writeCache(cache, { old: 'x'.repeat(10) });
writeCache(profile, { big: 'x'.repeat(100) });
assert.equal(saveShaderCache(cache, profile, 50), 'too-large');
assert.equal(existsSync(join(cache, SHADER_CACHE_PROFILE_FOLDER)), false);
writeCache(cache, { big: 'x'.repeat(100) });
const next = makeFolder();
assert.equal(seedShaderCache(cache, next, 50), 'too-large');
assert.equal(existsSync(join(cache, SHADER_CACHE_PROFILE_FOLDER)), false);
assert.equal(existsSync(join(next, SHADER_CACHE_PROFILE_FOLDER)), false);
assert.equal(folderBytes(join(tmpdir(), 'crucible-no-such-folder')), 0);
});
test('a cache another process is saving is skipped on seed and on save, a dead writer lock is not', () => {
const cache = makeFolder();
const profile = makeFolder();
writeCache(cache, { old: 'old' });
writeCache(profile, { fresh: 'fresh' });
const lock = join(cache, '.write-lock');
mkdirSync(lock);
assert.equal(isWriteLocked(cache), true);
assert.equal(seedShaderCache(cache, makeFolder()), 'locked');
assert.equal(saveShaderCache(cache, profile), 'locked');
assert.deepEqual(readCache(cache), { old: 'old' });
assert.deepEqual(readdirSync(cache).sort(), ['.write-lock', 'Default']);
const longAgo = new Date(Date.now() - 120_000);
utimesSync(lock, longAgo, longAgo);
assert.equal(isWriteLocked(cache), false);
assert.equal(saveShaderCache(cache, profile), 'saved');
assert.deepEqual(readCache(cache), { fresh: 'fresh' });
assert.equal(existsSync(lock), false);
});
test('a browser started with the cache gets the seed, and closing saves the new cache and deletes the profile', async () => {
const cache = makeFolder();
writeCache(cache, { first: 'one' });
let profileFolder;
const fakeChromium = {
async launchPersistentContext(folder, options) {
profileFolder = folder;
assert.equal(options.headless, true);
assert.deepEqual(readCache(folder), { first: 'one' });
return {
on() {},
async newPage() { return { setViewportSize: async () => {} }; },
async close() { writeFileSync(join(folder, SHADER_CACHE_PROFILE_FOLDER, 'second'), 'two'); },
};
},
};
const browser = await launchWithShaderCache(fakeChromium, { headless: true }, cache);
assert.equal(browser.isConnected(), true);
await browser.close();
assert.deepEqual(readCache(cache), { first: 'one', second: 'two' });
assert.equal(existsSync(profileFolder), false);
});
test('a browser that fails to start leaves no profile behind', async () => {
let profileFolder;
const failingChromium = { async launchPersistentContext(folder) { profileFolder = folder; throw new Error('no chrome'); } };
await assert.rejects(() => launchWithShaderCache(failingChromium, {}, makeFolder()), /no chrome/);
assert.equal(existsSync(profileFolder), false);
rmSync(profileFolder, { recursive: true, force: true });
});