@osmo.inc/cli-linux-arm64 0.1.22 → 0.1.24

package/runtime/packages/render-protocol/src/film-resources.mjs

@@ -0,0 +1,91 @@
+// Pinned data shared by the backend catalogue, CLI, and native compiler.
+// Existing table URLs/checksums are immutable. Bump this version when adding tables.
+import catalog from "./film-catalog.json" with { type: "json" };
+export const FILM_RESOURCE_VERSION = "1.0.0";
+export const FILM_TABLE_BYTES = 65 ** 3 * 12;
+export const FILM_TABLE_BASE = "https://osmo.inc/api/35mm/tables";
+export const filmStocks = catalog.items;
+export const filmTables = [
+	...new Map(
+		filmStocks.flatMap((stock) =>
+			[stock, ...Object.values(stock.tables)].map((table) => [
+				table.hash,
+				{
+					hash: table.hash,
+					sha256: table.sha256,
+					bytes: FILM_TABLE_BYTES,
+					url: `${FILM_TABLE_BASE}/${table.hash}.bin`,
+				},
+			]),
+		),
+	).values(),
+];
+export function filmResource(name = "film", version = FILM_RESOURCE_VERSION) {
+	if (version !== FILM_RESOURCE_VERSION) return undefined;
+	// Numbers are append-only catalogue identities; labels can change.
+	const stocks =
+		name === "film"
+			? filmStocks
+			: filmStocks.filter((s) => name === `film-${s.number}`);
+	if (!stocks.length) return undefined;
+	const hashes = new Set(
+		stocks.flatMap((s) => [
+			s.hash,
+			...Object.values(s.tables).map((t) => t.hash),
+		]),
+	);
+	return {
+		id: `osmo/${name}`,
+		title: name === "film" ? "Film looks" : `Film look: ${stocks[0].label}`,
+		summary:
+			name === "film"
+				? "All film looks, installed once for every local project."
+				: `${stocks[0].label}, with all camera variants. Installed once for every local project.`,
+		use: /** @type {const} */ ("get"),
+		kind: /** @type {const} */ ("film"),
+		tags: [
+			"film",
+			"color",
+			"offline",
+			...new Set(stocks.map((s) => s.collection)),
+		],
+		version,
+		package: {
+			folder: name,
+			version,
+			primitive: "Film",
+			installScope: /** @type {const} */ ("global"),
+			compatibility: { scene: "0.1.0" },
+			files: filmTables
+				.filter((t) => hashes.has(t.hash))
+				.map((t) => ({ path: `${t.hash}.bin`, ...t })),
+			presets: stocks.map((s) => ({ id: s.id, title: s.label })),
+			defaultPreset: stocks[0].id,
+			previews: [],
+			requiresLogin: false,
+			notes: [
+				"Film data is shared by all projects and preserved across CLI updates. Missing tables also install automatically when used.",
+			],
+		},
+	};
+}
+export const filmResourceItems = [
+	filmResource(),
+	...filmStocks.map((s) => filmResource(`film-${s.number}`)),
+].map((detail) => {
+	const { package: _package, ...item } = detail;
+	return item;
+});
+
+/** Collect dependencies from evaluated frames, including compositions, text
+ * animation states and motion-blur samples. Never infer them from source text. */
+export function collectFilmKeys(value, keys = new Set()) {
+	if (!value || typeof value !== "object") return keys;
+	for (const effect of value.effects ?? [])
+		if (typeof effect.film === "string") keys.add(effect.film);
+	for (const child of value.children ?? []) collectFilmKeys(child, keys);
+	for (const state of value.animate?.states ?? []) collectFilmKeys(state, keys);
+	for (const sample of value.motionSamples ?? []) collectFilmKeys(sample, keys);
+	if (value.scene) collectFilmKeys(value.scene, keys);
+	return keys;
+}

package/runtime/packages/render-protocol/src/film-store.node.mjs

@@ -0,0 +1,220 @@
+// Node-only resource installer. Do not export this from the browser protocol entry.
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile, rename, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { filmTables } from "./film-resources.mjs";
+
+export function filmDirectory(
+	env = process.env,
+	platform = process.platform,
+	home = os.homedir(),
+) {
+	if (env.OSMO_FILM_TABLES) return path.resolve(env.OSMO_FILM_TABLES);
+	const base =
+		platform === "darwin"
+			? path.join(home, "Library/Application Support/Osmo")
+			: platform === "win32"
+				? path.join(
+						env.LOCALAPPDATA || path.join(home, "AppData/Local"),
+						"Osmo",
+					)
+				: path.join(
+						env.XDG_DATA_HOME || path.join(home, ".local/share"),
+						"osmo",
+					);
+	return path.join(base, "resources/film");
+}
+const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const valid = (bytes, table) =>
+	bytes?.length === table.bytes && digest(bytes) === table.sha256;
+
+/** @typedef {{key:string, state:'checking'|'downloading'|'installed'|'failed', received:number, total:number, error?:string}} FilmProgress */
+/** @param {{directory?:string, tables?:typeof filmTables, fetch?:typeof globalThis.fetch, onProgress?:(progress:FilmProgress)=>void}} options */
+export function createFilmStore(options = {}) {
+	const directory = options.directory ?? filmDirectory();
+	const tables = new Map(
+		(options.tables ?? filmTables).map((t) => [`film:${t.hash}`, t]),
+	);
+	const pending = new Map();
+	/** @type {Map<string, FilmProgress>} */
+	const progress = new Map();
+	function tableFor(key) {
+		const table = tables.get(key);
+		if (!table) throw new Error(`Unknown film table: ${key}`);
+		return table;
+	}
+	function report(key, state, received = 0, error = undefined) {
+		const value = {
+			key,
+			state,
+			received,
+			total: tableFor(key).bytes,
+			...(error ? { error } : {}),
+		};
+		progress.set(key, value);
+		options.onProgress?.(value);
+	}
+	async function cached(table) {
+		const file = path.join(directory, `${table.hash}.bin`);
+		try {
+			if ((await stat(file)).size !== table.bytes) return null;
+			const bytes = await readFile(file);
+			return valid(bytes, table) ? bytes : null;
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+	}
+	async function install(key) {
+		const table = tableFor(key),
+			file = path.join(directory, `${table.hash}.bin`);
+		report(key, "checking");
+		const previous = await cached(table);
+		if (previous) {
+			report(key, "installed", table.bytes);
+			return previous;
+		}
+		await mkdir(directory, { recursive: true });
+		// Locks coalesce downloads across CLI commands, native compilers, and Studio.
+		// A crashed writer's lock expires after its bounded network deadline.
+		const lock = `${file}.lock`,
+			started = Date.now();
+		let held = false;
+		const temporary = `${file}.${randomUUID()}.tmp`;
+		try {
+			while (!held) {
+				try {
+					await mkdir(lock);
+					held = true;
+				} catch (error) {
+					if (error.code !== "EEXIST") throw error;
+					const bytes = await cached(table);
+					if (bytes) {
+						report(key, "installed", table.bytes);
+						return bytes;
+					}
+					const info = await stat(lock).catch(() => null);
+					if (info && Date.now() - info.mtimeMs > 180000) {
+						await rm(lock, { recursive: true, force: true });
+						continue;
+					}
+					if (Date.now() - started > 210000)
+						throw new Error(
+							"Another film installation is still running. Retry shortly.",
+						);
+					report(key, "downloading");
+					await delay(200);
+				}
+			}
+			const bytes = await cached(table);
+			if (bytes) {
+				report(key, "installed", table.bytes);
+				return bytes;
+			}
+			report(key, "downloading");
+			const response = await (options.fetch ?? globalThis.fetch)(table.url, {
+				signal: AbortSignal.timeout(120000),
+				redirect: "error",
+			});
+			if (!response.ok || !response.body) {
+				await response.body?.cancel();
+				throw new Error(`HTTP ${response.status}`);
+			}
+			const reader = response.body.getReader(),
+				data = Buffer.alloc(table.bytes);
+			let received = 0;
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (received + value.length > data.length)
+						throw new Error("Film table exceeds its declared size");
+					data.set(value, received);
+					received += value.length;
+					report(key, "downloading", received);
+				}
+			} finally {
+				await reader.cancel().catch(() => {});
+			}
+			if (received !== data.length || !valid(data, table))
+				throw new Error("Film table checksum or size mismatch");
+			await writeFile(temporary, data, { flag: "wx" });
+			await rename(temporary, file);
+			report(key, "installed", table.bytes);
+			return data;
+		} finally {
+			await rm(temporary, { force: true });
+			if (held) await rm(lock, { recursive: true, force: true });
+		}
+	}
+	function ensure(key) {
+		tableFor(key); // Reject unknown paths before touching the filesystem/network.
+		if (pending.has(key)) return pending.get(key);
+		const task = install(key)
+			.catch((cause) => {
+				const error = new Error(
+					`Film resource unavailable: ${key}. ${cause.message}. Check your connection and retry, or run osmo resources get film while online.`,
+				);
+				report(key, "failed", 0, error.message);
+				throw error;
+			})
+			.finally(() => pending.delete(key));
+		pending.set(key, task);
+		return task;
+	}
+	async function status(keys) {
+		const result = [];
+		// Bound memory even when inspecting the entire 1.16 GiB library.
+		for (const key of new Set(keys)) {
+			const table = tableFor(key);
+			if (pending.has(key)) result.push(progress.get(key));
+			else if (await cached(table))
+				result.push({
+					key,
+					state: "installed",
+					received: table.bytes,
+					total: table.bytes,
+				});
+			else
+				result.push(
+					progress.get(key)?.state === "failed"
+						? progress.get(key)
+						: { key, state: "missing", received: 0, total: table.bytes },
+				);
+		}
+		return result;
+	}
+	async function ensureAll(keys, onDone = (_done, _total) => {}) {
+		const unique = [...new Set(keys)];
+		unique.forEach(tableFor);
+		const queue = [...unique];
+		let done = 0,
+			failed = false;
+		// Settle active workers before returning an error; never leave background writes.
+		const results = await Promise.allSettled(
+			Array.from({ length: Math.min(4, queue.length) }, async () => {
+				while (queue.length && !failed) {
+					try {
+						await ensure(queue.shift());
+						onDone(++done, unique.length);
+					} catch (error) {
+						failed = true;
+						throw error;
+					}
+				}
+			}),
+		);
+		const failure = results.find((result) => result.status === "rejected");
+		if (failure?.status === "rejected") throw failure.reason;
+		return { directory, tables: unique.length };
+	}
+	return { directory, ensure, ensureAll, status };
+}
+// One instance per process; native compiler processes share its on-disk locks.
+let shared;
+export function filmStore() {
+	shared ??= createFilmStore();
+	return shared;
+}

package/runtime/packages/scene/scripts/sync-film.mjs

@@ -0,0 +1,8 @@
+// Keep the standalone authoring package independent of private workspace packages.
+// Its generated catalog is checked against the engine's canonical catalog in tests.
+import { readFile, writeFile } from 'node:fs/promises';
+const root = new URL('../', import.meta.url);
+const catalog = JSON.parse(await readFile(new URL('../render-protocol/src/film-catalog.json', root), 'utf8'));
+const cameras = await readFile(new URL('../render-protocol/src/film-cameras.ts', root), 'utf8');
+const names = JSON.parse(cameras.slice(cameras.indexOf('['), cameras.lastIndexOf(']') + 1).replace(/,\s*]/g, ']'));
+await writeFile(new URL('src/film-catalog.generated.ts', root), '// Generated by scripts/sync-film.mjs; do not edit.\nexport const FILM_STOCKS = ' + JSON.stringify(catalog.items) + ';\nexport const FILM_CAMERAS = ' + JSON.stringify(names) + ' as const;\n');

package/runtime/packages/scene/scripts/validate-strict.mjs

@@ -35,7 +35,7 @@ export function validate(file, mode, options = {}) {
         const p = ast.getLineAndCharacterOfPosition(d.start);
         errors.push(`${p.line + 1}:${p.character + 1} ${ts.flattenDiagnosticMessageText(d.messageText, '\n')}`);
     }
-    const allowed = new Set(['Scene', 'Camera', 'Group', 'Rect', 'Path', 'Text', 'Image', 'Video', 'Audio', 'Model', 'Surface', 'Fragment', 'defineMotion', 'defineKnobs', 'Shader', 'sampleMotion', 'describeMotion', 'blur', 'grain']);
+    const allowed = new Set(['Scene', 'Camera', 'Group', 'Rect', 'Path', 'Text', 'Image', 'Video', 'Audio', 'Model', 'Surface', 'Fragment', 'defineMotion', 'defineKnobs', 'Shader', 'sampleMotion', 'describeMotion', 'blur', 'grain', 'film']);
     allowed.add('defineEffect');
     const importedGroups = new Set(), sourceIds = new Set(), effects = new Set();
     const tracks = new Map();
@@ -72,11 +72,16 @@ export function validate(file, mode, options = {}) {
         if (refs && ts.isIdentifier(n) && knobSets.has(n.text)) return;
         if (refs && ts.isPropertyAccessExpression(n) && ts.isIdentifier(n.expression) && tracks.get(n.expression.text)?.has(n.name.text))
             return;
-        if (refs && ts.isCallExpression(n) && ts.isIdentifier(n.expression) && (['blur', 'grain'].includes(n.expression.text)||effects.has(n.expression.text)) && n.arguments.length <= 1) {
+        if (refs && ts.isCallExpression(n) && ts.isIdentifier(n.expression) && (['blur', 'grain', 'film'].includes(n.expression.text)||effects.has(n.expression.text)) && n.arguments.length <= 2) {
             if(n.arguments[0])value(n.arguments[0]);
+            const options = n.arguments[1];
+            if (options && (!ts.isObjectLiteralExpression(options) || options.properties.some(p =>
+                !ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name) || p.name.text !== "enabled" ||
+                ![ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword].includes(p.initializer.kind))))
+                fail(options, "Effect options must be a literal { enabled: boolean }");
             return;
         }
-        fail(n, 'Strict accepts literals, literal collections, declared motion/knob references, declared effects, blur and grain only');
+        fail(n, 'Strict accepts literals, literal collections, declared motion/knob references, declared effects, blur, grain and film only');
     }
     for (const st of ast.statements) {
         if (ts.isImportDeclaration(st)) {
@@ -156,7 +161,7 @@ export function validate(file, mode, options = {}) {
             const lane = v && ts.isNumericLiteral(v) ? Number(v.text) : NaN;
             if (!Number.isInteger(lane) || lane < 0 || lane > 99) fail(track, 'track must be a literal integer from 0 to 99');
         }
-        if ((!allowed.has(tag) && !importedGroups.has(tag)) || ['defineMotion', 'defineKnobs', 'defineEffect', 'sampleMotion', 'describeMotion', 'blur', 'grain'].includes(tag))
+        if ((!allowed.has(tag) && !importedGroups.has(tag)) || ['defineMotion', 'defineKnobs', 'defineEffect', 'sampleMotion', 'describeMotion', 'blur', 'grain', 'film'].includes(tag))
             fail(el, 'Use public visual primitives only');
         if (importedGroups.has(tag) && ts.isJsxElement(n) && n.children.some(c => !ts.isJsxText(c) || c.text.trim()))
             fail(n, 'Animation instances cannot replace children; edit the original Group file');
@@ -194,6 +199,11 @@ export function validate(file, mode, options = {}) {
                 else if (sourceIds.has(id.text)) fail(a, 'IDs must be unique within their source file');
                 else sourceIds.add(id.text);
             }
+            if (a.name.text === 'originalSrc') {
+                const src = a.initializer && (ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer);
+                if (tag !== 'Video' || !src || !ts.isStringLiteral(src) || !src.text.trim() || /^[a-z]+:/i.test(src.text))
+                    fail(a, 'Video.originalSrc must be a static local path');
+            }
             if (tag === 'Shader' && a.name.text === 'src') {
                 const src = a.initializer && (ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer);
                 if (!src || !ts.isStringLiteral(src) || !src.text.trim() || /^[a-z]+:/i.test(src.text) || path.isAbsolute(src.text) || !/\.wgsl$/i.test(src.text))

package/runtime/packages/scene/scripts/verify-export-resolution.mjs

@@ -0,0 +1,67 @@
+// Real browser WebGPU regression checks for export-layer resolution.
+// Requires built engine WASM, Chrome, FFmpeg and tools/engine-lab dependencies.
+// node packages/scene/scripts/verify-export-resolution.mjs
+import assert from 'node:assert/strict';
+import {createServer} from 'node:http';
+import {execFileSync} from 'node:child_process';
+import {createRequire} from 'node:module';
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+const repo=fileURLToPath(new URL('../../../',import.meta.url));
+const require=createRequire(path.join(repo,'tools/engine-lab/package.json'));
+const {chromium}=require('playwright-core');
+const stage=`import init,{create_engine,SceneEncoder} from '/engine.js';
+await init();const canvas=document.querySelector('canvas');
+const engine=await create_engine(canvas),encoder=new SceneEncoder();
+engine.set_mode(0);engine.set_effect(0);engine.set_orbit(0,0);engine.set_dither(0);
+engine.set_render_scale(1);engine.set_transparent(true);engine.set_exporting(true);
+window.draw=async(meta,scene)=>{
+ canvas.width=meta.width;canvas.height=meta.height;engine.resize(meta.width,meta.height);
+ engine.update_scene(encoder.encode(JSON.stringify(meta),JSON.stringify(scene),engine));
+ engine.render(0);await engine.submitted_work_done();return canvas.toDataURL();
+};window.ready=true;`;
+const server=createServer(async(req,res)=>{try{
+ const name=new URL(req.url,'http://localhost').pathname;
+ if(name==='/'){res.setHeader('content-type','text/html');res.end('<canvas></canvas><script type="module" src="/stage.js"></script>');return;}
+ if(name==='/stage.js'){res.setHeader('content-type','text/javascript');res.end(stage);return;}
+ if(!['/engine.js','/engine_bg.wasm'].includes(name)){res.writeHead(404);res.end();return;}
+ res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript');
+ res.end(await readFile(path.join(repo,'packages/render-engine/pkg',name.slice(1))));
+}catch(e){res.writeHead(500);res.end(String(e));}});
+const transform=scale=>({position:[0,0],scale:[scale,scale],rotation:0,origin:[0,0],opacity:1});
+const group=(w,h,scale,children)=>({type:'group',width:w,height:h,clip:true,transform:transform(scale),children});
+const artwork=scale=>[
+ {type:'path',d:'M16 30C16 2 96 2 96 30C96 58 16 58 16 30Z M30 30C30 44 82 44 82 30C82 16 30 16 30 30Z',fill:'#ffffff',fillRule:'evenodd',transform:transform(scale)},
+ {type:'text',text:'/osmo',font:'Inter',fontSize:18,color:'#ffffff',align:'left',lineHeight:1.2,letterSpacing:0,width:120,height:32,transform:{...transform(scale),position:[8*scale,60*scale]}},
+];
+const fixture=(scale,reference)=>{
+ const authored=reference?scale:1,innerScale=reference?1:scale/2;
+ const inner=group(128*authored,96*authored,innerScale,[
+  {type:'rect',width:120*authored,height:90*authored,radius:4*authored,fill:'#ffffff',transform:transform(1)},...artwork(authored)]);
+ inner.mask={index:0,mode:'alpha',invert:false};
+ const outer=group(128*(reference?authored:innerScale),96*(reference?authored:innerScale),reference?1:2,[inner]);
+ outer.transform.opacity=0.75;return [outer];
+};
+let browser;
+try{
+ await new Promise((ok,fail)=>{server.once('error',fail);server.listen(0,'127.0.0.1',ok);});
+ browser=await chromium.launch({channel:'chrome',headless:true});
+ const page=await browser.newPage();await page.goto(`http://127.0.0.1:${server.address().port}/`);
+ await page.waitForFunction(()=>window.ready);
+ async function draw(width,height,children){
+  const meta={version:1,source:'resolution.tsx',width,height,fps:24,totalFrames:1,duration:1/24};
+  const uri=await page.evaluate(([m,s])=>window.draw(m,s),[meta,{time:0,background:'transparent',children}]);
+  return execFileSync('ffmpeg',['-v','error','-i','pipe:0','-f','rawvideo','-pix_fmt','rgba','-'],{input:Buffer.from(uri.split(',')[1],'base64'),maxBuffer:32*1024*1024});
+ }
+ const compare=(a,b,label)=>{
+  let sum=0,count=0;for(let i=3;i<a.length;i+=4){if(a[i]||b[i]){sum+=Math.abs(a[i]-b[i]);count++;}}
+  assert.ok(count>500,'fixture paints visible content');const mean=sum/count;
+  assert.ok(mean<1.5,`${label}: mean coverage error ${mean}`);console.log(JSON.stringify({label,mean}));
+ };
+ for(const scale of [2,3,5.04])compare(await draw(768,512,fixture(scale,false)),await draw(768,512,fixture(scale,true)),`nested masked text/vector at ${scale}x`);
+ const bars=Array.from({length:375},(_,i)=>({type:'rect',width:1,height:48,radius:0,fill:'#ffffff',transform:{...transform(1),position:[4200+4*i,8]}}));
+ const reference=await draw(5760,64,bars);
+ compare(reference,await draw(5760,64,[group(5760,64,1,bars)]),'6K single-pixel detail');
+ compare(reference,await draw(5760,64,[{type:'composition',width:5760,height:64,transform:transform(1),scene:{time:0,background:'transparent',children:[group(5760,64,1,bars)]}}]),'6K nested scene inherits export quality');
+}finally{await browser?.close();await new Promise(ok=>server.close(ok));}

package/runtime/packages/scene/scripts/verify-film.mjs

@@ -0,0 +1,66 @@
+// Real browser WebGPU / native Metal parity for the public TSX film() effect.
+// Requires Chrome, FFmpeg, the built native renderer/WASM, and verified LUTs.
+// node packages/scene/scripts/verify-film.mjs /tmp/film-parity
+import {createServer} from 'node:http';
+import {createRequire} from 'node:module';
+import {execFileSync} from 'node:child_process';
+import {mkdir,readFile,writeFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+const repo=fileURLToPath(new URL('../../../',import.meta.url));
+const output=path.resolve(process.argv[2]??'/tmp/osmo-film-parity');await mkdir(output,{recursive:true});
+const {chromium}=createRequire(path.join(repo,'tools/engine-lab/package.json'))('playwright-core');
+const native=process.env.OSMO_NATIVE_BIN??path.join(repo,'apps/native/target/debug/osmo-lite');
+const frames=[0,2,5],results=[];
+const cameras=['Studio (automatic)','BMDFilm Gen 5 | BMD Wide Gamut','Arri LogC4 | Arri Wide Gamut 4','Sony S-Log3 | S-Gamut3.Cine'];
+const stage=`import init,{create_engine,SceneEncoder} from '/engine.js';
+await init();const canvas=document.querySelector('canvas');canvas.width=128;canvas.height=72;
+const engine=await create_engine(canvas),encoder=new SceneEncoder();
+engine.set_mode(0);engine.set_effect(0);engine.set_orbit(0,0);engine.set_dither(0);engine.set_render_scale(1);engine.set_transparent(true);
+window.draw=async(meta,scene)=>{
+ const keys=new Set();const visit=n=>{for(const fx of n.effects??[])if(fx.film)keys.add(fx.film);for(const child of n.children??[])visit(child);if(n.scene)visit(n.scene);};visit(scene);
+ for(const key of keys)if(!engine.has_film_table(key)){const r=await fetch('/tables/'+key.slice(5)+'.bin');if(!r.ok)throw Error('Missing film');if(!engine.add_image_encoded(key,new Uint8Array(await r.arrayBuffer())))throw Error('Invalid film');}
+ engine.update_scene(encoder.encode(JSON.stringify(meta),JSON.stringify(scene),engine));engine.render(scene.time);await engine.submitted_work_done();return canvas.toDataURL();
+};window.ready=true;`;
+const server=createServer(async(req,res)=>{try{
+ const name=new URL(req.url,'http://localhost').pathname;
+ if(name==='/'){res.setHeader('content-type','text/html');res.end('<canvas></canvas><script type="module" src="/stage.js"></script>');return;}
+ if(name==='/stage.js'){res.setHeader('content-type','text/javascript');res.end(stage);return;}
+ let file;
+ if(['/engine.js','/engine_bg.wasm'].includes(name)){file=path.join(repo,'packages/render-engine/pkg',name.slice(1));res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript');}
+ else if(/^\/tables\/[a-f0-9]+(?:-logc4|-slog3cine)?\.bin$/.test(name))file=path.join(process.env.OSMO_FILM_TABLES??path.join(repo,'packages/render-engine/assets/film'),path.basename(name));
+ else {res.writeHead(404);res.end();return;}
+ res.end(await readFile(file));
+}catch(e){res.writeHead(500);res.end(String(e));}});
+let browser;
+try {
+ await new Promise((ok,fail)=>{server.once('error',fail);server.listen(0,'127.0.0.1',ok);});
+ browser=await chromium.launch({channel:'chrome',headless:true});
+ const page=await browser.newPage();await page.goto(`http://127.0.0.1:${server.address().port}/`);await page.waitForFunction(()=>window.ready);
+ for(const [index,cameraProfile] of cameras.entries()) {
+  const source=path.join(output,`scene-${index}.tsx`),snapshot=path.join(output,`scene-${index}.jsonl`);
+  const sourceText=`import {Scene,Group,Rect,film} from '@osmo/scene';
+   export default <Scene width={128} height={72} fps={24} duration={0.25} background="#28392d">
+   <Group width={128} height={72} effects={[film({stock:'500t',cameraProfile:${JSON.stringify(cameraProfile)},seed:42,grain:0.5,exposure:0.2})]}>
+   <Rect width={128} height={72} fill="#707c80"/><Rect position={[8,8]} width={32} height={56} fill="#b86a43"/><Rect position={[48,8]} width={32} height={56} fill="#46687d"/><Rect position={[88,8]} width={32} height={56} fill="#ece8da"/>
+   </Group></Scene>;`;
+  await writeFile(source,sourceText);
+  // The compiler deliberately refuses overwriting snapshots.
+  const {rm}=await import('node:fs/promises');await rm(snapshot,{force:true});
+  execFileSync(process.execPath,[path.join(repo,'apps/native/tools/compile.mjs'),source,snapshot],{stdio:'pipe'});
+  for(const frame of frames) await rm(path.join(output,`native-${index}-${frame}.png`),{force:true});
+  execFileSync(native,['--scene-snapshot',snapshot,'--snapshot',path.join(output,`native-${index}.png`),'--frame',frames.join(',')],{env:{...process.env,OSMO_TEST_NO_DITHER:'1'},stdio:'pipe'});
+  const [meta,...scenes]=(await readFile(snapshot,'utf8')).trim().split('\n').map(JSON.parse);
+  for(const frame of frames) {
+   const uri=await page.evaluate(([meta,scene])=>window.draw(meta,scene),[meta,scenes[frame]]);
+   const file=path.join(output,`browser-${index}-${frame}.png`);await writeFile(file,Buffer.from(uri.split(',')[1],'base64'));
+   const pixels=f=>execFileSync(process.env.OSMO_FFMPEG??'ffmpeg',['-v','error','-i',f,'-f','rawvideo','-pix_fmt','rgba','-']);
+   const a=pixels(path.join(output,`native-${index}-${frame}.png`)),b=pixels(file);assert.equal(a.length,b.length);
+   let max=0,sum=0,different=0;for(let i=0;i<a.length;i++){const d=Math.abs(a[i]-b[i]);max=Math.max(max,d);sum+=d;if(d)different++;}
+   const result={cameraProfile,frame,max,mean:sum/a.length,different,total:a.length};results.push(result);
+   assert.ok(max<=2,JSON.stringify(result));
+  }
+ }
+ await writeFile(path.join(output,'results.json'),JSON.stringify(results,null,2)+'\n');console.log(JSON.stringify(results));
+} finally {await browser?.close();await new Promise(ok=>server.close(ok));}