Couldn't an async component be made by making the compiler restore the Owner manually?

[AFatNiBBa]

Problem

We currently can't create a component like this

const exampleOfAsyncFunction = (ms: number) => new Promise<number>(t => setTimeout(() => t(ms), ms));

async function Comp() {
  const first = await exampleOfAsyncFunction(1000);
  // stuff 1...
  const second = await exampleOfAsyncFunction(2000);
  // stuff 2...
  console.log(getOwner()); // → null
  return <>
    {/* Calls `toString()` in order to make the compiler wrap the values in `createMemo()` */}
    {first.toString(16)} - {second.toString(16)}
  </>
}

because after the first await the Owner and contexts would be lost, effects wouldn't be disposed and the component should be wrapped in a createResource() when used

Solution

Couldn't it be possible to get the compiler to manually restore the state after each await?
The output would go from this

async function Comp() {
  const first = await delay(1000);
  // stuff 1...
  const second = await delay(2000);
  // stuff 2...
  console.log(getOwner()); // → null
  return [_$memo(() => first.toString(16)), " - ", _$memo(() => second.toString(16))];
}

to this

function Comp() {
  const _$owner = getOwner();
  return createResource(async () => {
    const _$var1 = await delay(1000); 
    return runWithOwner(_$owner, async () => {
      const first = _$var1;
      // stuff 1...
      const _$var2 = await delay(2000); 
      return runWithOwner(_$owner, async () => {
        const second = _$var2;
        // stuff 2...
        console.log(getOwner()); // → (_$owner)
        return [_$memo(() => first.toString(16)), " - ", _$memo(() => second.toString(16))];
      });
    });
  })[0];
}