About Decimal and primitives, littledan's logic makes a lot of sense to me. If we were to have decimals as a primitive, they would need to be normalized (no quantum). However, the champions have presented rationale for why decimals should retain their quantum. Therefore, Decimals should be objects, not primitives.

This logic flows completely independently from any argument about whether or not engines may eventually change their position on decimals being a new primitive.

In the old days, folk learned JS before they learned TS, so had a strong mental model of the difference.

Nowadays many people learn TS first (or at least, it's not sequenced).

And we have runtimes with built-in support, further hiding the difference.

is the only way to observe number of ticks via user code then handlers?

if i have some spec doing the following:

let p1 = new %Promise%;
let p2 = new %Promise%;
PerformPromiseThen(p2, () => p1, () => {});
return p2;

where p1 and p2 are built-in promises, and p1 never escapes to user code, are the two ticks unobservable? is that equivalent to returning p1 directly?

(async () => {
  for (let i = 0; i < 4; ++i) {
    console.log(i);
    await 0;
  }
})();

// compare:
(async () => {
  let p1 = Promise.resolve();
  
  p1.then(() => { console.log('done 1'); });
})();

// vs:
(async () => {
  let p1 = Promise.resolve();
  
  let resolveP2;
  let p2 = new Promise(res => { resolveP2 = res; });
  
  p1.then(resolveP2);
  
  p2.then(() => { console.log('done 2'); });
})();