USD mesh coordinates in saved and exported files

const area = L.kind === 'area' ? L.size[0] * L.size[1] : Math.max(1e-6, 4 * Math.PI * (L.size[0] / 2) ** 2);
this.attr(p, 'inputs:intensity', 'float', L.lumens / (683 * area * Math.PI));

const packScalar = (base, d, x) => {
  const e = d.e;
  if (base === 'pathExpression') return rep(e, at(null, () => w.u32(str(x))));
  if (d.n === 1) {
    switch (d.k) {
      case 'bool': return rep(e, x ? 1 : 0, { inline: true });
      case 'u8': return rep(e, x & 0xff, { inline: true });
      case 'i32': return rep(e, (x | 0) >>> 0, { inline: true });
      case 'u32': return rep(e, x >>> 0, { inline: true });
      case 'f16': return rep(e, floatToHalf(x), { inline: true });
      case 'f32': { F.setFloat32(0, x, true); return rep(e, F.getUint32(0, true), { inline: true }); }
      case 'str': return rep(e, str(x), { inline: true });
      case 'tok': case 'asset': return rep(e, tok(x), { inline: true });
      case 'f64':
        if (base !== 'timecode' && Object.is(Math.fround(x), x) && Number.isFinite(x)) { F.setFloat32(0, x, true); return rep(e, F.getUint32(0, true), { inline: true }); }
        return rep(e, at(null, () => w.f64(x)));
      case 'i64': case 'u64': {
        const n = typeof x === 'bigint' ? x : BigInt(x);
        if (d.k === 'i64' && n >= -2147483648n && n <= 2147483647n) return rep(e, Number(BigInt.asUintN(32, n)), { inline: true });
        if (d.k === 'u64' && n >= 0n && n <= 4294967295n) return rep(e, Number(n), { inline: true });
        return rep(e, at(null, () => (d.k === 'i64' ? w.i64(n) : w.u64(n))));
      }
      default: break;
    }
  }
  const a = Array.from(x);
  if (d.mat) {
    const m = d.mat;
    let ok = true;
    for (let r = 0; r < m && ok; r++) for (let c = 0; c < m; c++) { const y = a[r * m + c]; if (r === c ? !isI8(y) : !Object.is(y, 0)) { ok = false; break; } }
    if (ok) { let pl = 0; for (let k = 0; k < m; k++) pl |= (a[k * m + k] & 0xff) << (8 * k); return rep(e, pl >>> 0, { inline: true }); }
    return rep(e, at(null, () => { for (const y of a) w.f64(y); }));
  }
  if (d.quat) return rep(e, at(null, () => { for (const y of quatToMemory(a)) writeScalar(d.k, y); }));
  if (a.every(isI8)) { let pl = 0; for (let k = 0; k < d.n; k++) pl |= (a[k] & 0xff) << (8 * k); return rep(e, pl >>> 0, { inline: true }); }
  return rep(e, at(null, () => { for (const y of a) writeScalar(d.k, y); }));
};

/** The built-in shapes as meshes (fallback sizes from the schema). */
export function shapeMesh(prim, time) {
  const t = prim.typeName;
  const P = [], C = [], I = [];
  const quad = (a, b, c, d) => { C.push(4); I.push(a, b, c, d); };
  const tri = (a, b, c) => { C.push(3); I.push(a, b, c); };
  const v = (x, y, z) => { P.push(x, y, z); return P.length / 3 - 1; };
  if (t === 'Cube') {
    const s = num(prim, 'size', time, 2) / 2;
    for (const [x, y, z] of [[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]) v(x * s, y * s, z * s);
    quad(0, 3, 2, 1); quad(4, 5, 6, 7); quad(0, 1, 5, 4); quad(1, 2, 6, 5); quad(2, 3, 7, 6); quad(3, 0, 4, 7);
    return out(P, C, I);
  }
  if (t === 'Sphere') {
    const r = num(prim, 'radius', time, 1), rings = SEG / 2;
    const top = v(0, 0, r), bot = v(0, 0, -r);
    const ring = [];
    for (let i = 1; i < rings; i++) {
      const ph = (Math.PI * i) / rings, row = [];
      for (let j = 0; j < SEG; j++) { const th = (2 * Math.PI * j) / SEG; row.push(v(r * Math.sin(ph) * Math.cos(th), r * Math.sin(ph) * Math.sin(th), r * Math.cos(ph))); }
      ring.push(row);
    }
    for (let j = 0; j < SEG; j++) {
      const k = (j + 1) % SEG;
      tri(top, ring[0][j], ring[0][k]);
      for (let i = 0; i < ring.length - 1; i++) quad(ring[i][j], ring[i + 1][j], ring[i + 1][k], ring[i][k]);
      tri(bot, ring[ring.length - 1][k], ring[ring.length - 1][j]);
    }
    return axisTurn(out(P, C, I), 'Z');
  }
  if (t === 'Cylinder' || t === 'Cone' || t === 'Capsule') {
    const h = num(prim, 'height', time, t === 'Capsule' ? 1 : 2), r = num(prim, 'radius', time, t === 'Capsule' ? 0.5 : 1);
    const axis = tokenOf(prim, 'axis', 'Z');
    const z0 = -h / 2, z1 = h / 2;
    const ringAt = (z, rr) => { const row = []; for (let j = 0; j < SEG; j++) { const th = (2 * Math.PI * j) / SEG; row.push(v(rr * Math.cos(th), rr * Math.sin(th), z)); } return row; };
    if (t === 'Cone') {
      const b = ringAt(z0, r), apex = v(0, 0, z1), c0 = v(0, 0, z0);
      for (let j = 0; j < SEG; j++) { const k = (j + 1) % SEG; tri(b[j], b[k], apex); tri(c0, b[k], b[j]); }
    } else if (t === 'Cylinder') {
      const b = ringAt(z0, r), a = ringAt(z1, r), c0 = v(0, 0, z0), c1 = v(0, 0, z1);
      for (let j = 0; j < SEG; j++) { const k = (j + 1) % SEG; quad(b[j], b[k], a[k], a[j]); tri(c0, b[k], b[j]); tri(c1, a[j], a[k]); }
    } else {
      const rings = [];
      const half = SEG / 4;
      for (let i = half; i >= 0; i--) { const ph = (Math.PI / 2) * (i / half); rings.push(ringAt(z0 - r * Math.sin(ph), r * Math.cos(ph))); }
      for (let i = 0; i <= half; i++) { const ph = (Math.PI / 2) * (i / half); rings.push(ringAt(z1 + r * Math.sin(ph), r * Math.cos(ph))); }
      for (let i = 0; i < rings.length - 1; i++) for (let j = 0; j < SEG; j++) { const k = (j + 1) % SEG; quad(rings[i][j], rings[i][k], rings[i + 1][k], rings[i + 1][j]); }
    }
    return axisTurn(out(P, C, I), axis);
  }
  if (t === 'Plane') {
    const w = num(prim, 'width', time, 2) / 2, l = num(prim, 'length', time, 2) / 2;
    v(-w, -l, 0); v(w, -l, 0); v(w, l, 0); v(-w, l, 0);
    quad(0, 1, 2, 3);
    return axisTurn(out(P, C, I), tokenOf(prim, 'axis', 'Z'));
  }
  return null;
}