Render hand-off manifest

const round = (x, k = 6) => (Number.isFinite(x) ? Math.round(x * 10 ** k) / 10 ** k : 0);

/** sRGB hex → linear Rec.709, the USD file's own colour space for colours (USD-CONVENTIONS § 7). */
function hexToLinear(hex) {
  const n = parseInt(String(hex).slice(1, 7), 16) || 0;
  const c = (v) => { v /= 255; return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; };
  return [c((n >> 16) & 255), c((n >> 8) & 255), c(n & 255)].map((x) => round(x, 5));
}

const point = (m, p) => [0, 1, 2].map((r) => round(m[r] * p[0] + m[4 + r] * p[1] + m[8 + r] * p[2] + m[12 + r]));
const direction = (m, d) => { const v = [0, 1, 2].map((r) => m[r] * d[0] + m[4 + r] * d[1] + m[8 + r] * d[2]), l = Math.hypot(...v) || 1; return v.map((x) => round(x / l)); };

const ortho = Math.abs(proj[15] - 1) < 1e-9 && Math.abs(proj[11]) < 1e-9;
const camera = {
  projection: ortho ? 'orthographic' : settings.projection === 'normal' || !settings.projection ? 'perspective' : settings.projection,
  world: world.map((x) => round(x, 7)), proj: Array.from(proj).map((x) => round(x, 7)),
  position: point(M, [cam.world[12], cam.world[13], cam.world[14]]),
  forward: direction(world, [0, 0, -1]), up: direction(world, [0, 1, 0]), aspect: round(w / h, 5),
};
if (ortho) camera.orthoHeight = round(2 / Math.abs(proj[5]), 5);
else camera.fovY = round((2 * Math.atan(1 / Math.abs(proj[5])) * 180) / Math.PI, 4);

const sun = scene.sun ? { on: true, dir: direction(M, scene.sun), intensity: round(base.sun, 4), tint: base.tint, diameterDeg: 0.53 } : { on: false };
// lamps that are on, as the renderer draws them (the brightest 64), their IES profile beside the USD
const lamps = [], iesFiles = {};
for (const L of (scene.lights || []).filter((x) => x && x.on !== false && x.lumens > 0).sort((a, b) => b.lumens - a.lumens).slice(0, MAX_LAMPS)) {
  const o = { name: String(L.name || 'Lamp').slice(0, 120), kind: L.kind === 'spot' || L.kind === 'area' ? L.kind : 'point', lumens: round(L.lumens, 3), color: hexToLinear(typeof L.color === 'string' ? L.color : '#ffe7c4'), p: point(M, L.p || [0, 0, 0]), dir: direction(M, L.dir || [0, 0, -1]) };
  if (L.kind === 'spot') o.angle = round(num(L.angle, 90), 3);
  if (L.kind === 'area') o.size = vec(L.size, 2, 0.5);

const stops = cameraStops(settings);
const m = {
  format: MANIFEST_FORMAT,
  app: { name: app, version: appVersion },
  created: created || null,
  scene: { file: usdFile, upAxis: 'Z', metersPerUnit: 1, up: direction(M, scene.up || [0, 0, 1]), groundZ: settings.ground === false ? null : round(point(M, [0, 0, num(scene.groundAt)])[2], 5) },
  image: { width: w, height: h, quality: settings.quality, samples: Math.max(1, num(({ draft: 16, good: 64, best: 256 })[settings.quality], 64)), denoise: !!settings.denoise, minutes: settings.minutes },
  camera,
  cameras: (cameras || []).slice(0, MAX_CAMERAS).map((c) => ({ name: String(c.name || '').slice(0, 120), prim: String(c.prim || '').slice(0, 400) })),
  sun, sky,
  exposure: { stops: round(stops, 4), slider: settings.exposure, mode: settings.exposureMode, fstop: settings.fstop, shutter: round(settings.shutter, 6), iso: settings.iso },
  whiteBalance: { kelvin: settings.whiteBalance, gains: whiteBalance(settings.whiteBalance).map((x) => round(x, 5)) },

frames: frames ? { from: round(num(frames.from), 4), to: round(num(frames.to), 4), fps: Math.max(1, Math.min(240, Math.round(num(frames.fps, 24)))), count: Math.max(1, Math.min(100000, Math.round(num(frames.count, 1)))),
  cameras: (frames.cameras || []).slice(0, 100000).map((c) => ({ world: matMul(M, c.world).map((x) => round(x, 7)) })) } : null,

/**
 * The OpenPBR values of one of the apps' material keys (looks.js looks, materials.js `mat:` ids, `img:` textures, the ground) as
 * named parameters, only where they differ from OpenPBR's defaults (USD-CONVENTIONS § 7). Colours are linear Rec.709 triples.
 * The same mapping pt-pack.js `materialRecord` packs for our path tracer (RENDER-SPEC § 5.1), so the engines start from one material.
 */
export function openpbrFor(key, settings, scene) {
  let p;
  if (key === '__ground') p = { base_color: hexToLinear(SKIES[settings && settings.sky]?.plain ? '#f4f4f2' : '#cbc6bb'), specular_roughness: 1 };
  else if (typeof key === 'string' && key.startsWith('mat:') && libMaterial(key.slice(4))) {
    const m = libMaterial(key.slice(4));
    if (m.pbr) p = { ...m.pbr };
    else {
      p = { base_color: hexToLinear(m.color), specular_roughness: m.rough, base_metalness: m.metal || 0 };
      if (m.glass) Object.assign(p, { transmission_weight: m.glass, transmission_color: hexToLinear(m.color), specular_roughness: 0.02, geometry_thin_walled: true });
    }
  } else if (typeof key === 'string' && key.startsWith('img:')) {
    const avg = /#[0-9a-f]{6}$/i.exec(key);
    p = { base_color: hexToLinear(avg ? avg[0] : '#b4b4b4'), specular_roughness: 0.7 };
  } else {
    const L = lookFor(key, settings, scene && scene.defaultColor, scene && scene.looks && scene.looks[key]);
    p = { base_color: hexToLinear(L.color), specular_roughness: L.rough, base_metalness: L.metal };
    if (L.glass) Object.assign(p, { transmission_weight: L.glass, transmission_color: hexToLinear(L.color), geometry_thin_walled: true });
  }
  const out = {};
  for (const [k, v] of Object.entries(p)) {
    const d = OPENPBR_DEFAULTS[k];
    if (d === undefined) continue;
    const same = Array.isArray(d) ? Array.isArray(v) && v.length === d.length && v.every((x, i) => Math.abs(x - d[i]) < 1e-6) : v === d || (typeof v === 'number' && typeof d === 'number' && Math.abs(v - d) < 1e-9);
    if (!same) out[k] = Array.isArray(v) ? v.map((x) => round(x, 5)) : typeof v === 'number' ? round(v, 5) : v;
  }
  return out;
}