@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/compiler_promise_runner.ts

@@ -0,0 +1,2184 @@
+import { assertEquals } from '@std/assert';
+
+import { compileTempProject, createCompilerTestProject } from './compiler_object_test_helpers.ts';
+import {
+  instantiateCompiledModuleInJs,
+  resolveQualifiedExportName,
+} from './compiler_test_helpers.ts';
+
+type PromiseCompilerCase = {
+  name: string;
+  source: string;
+  expectedObserved?: number;
+  hostFunctions?: Record<string, (...args: unknown[]) => unknown>;
+  reducer?: 'last' | 'weighted';
+  run?: (exported: (...args: unknown[]) => unknown) => Promise<void>;
+};
+
+async function runPromiseCompilerCase(testCase: PromiseCompilerCase): Promise<void> {
+  const tempDirectory = await createCompilerTestProject(testCase.source);
+  const result = compileTempProject(tempDirectory);
+
+  assertEquals(result.exitCode, 0, testCase.name);
+  assertEquals(result.diagnostics, [], testCase.name);
+  const instance = await instantiateCompiledModuleInJs(tempDirectory, {
+    hostFunctions: testCase.hostFunctions,
+  });
+  const exportName = await resolveQualifiedExportName(tempDirectory, 'main');
+  const exported = instance.exports[exportName];
+  if (typeof exported !== 'function') {
+    throw new Error(`Expected exported function "${exportName}" for ${testCase.name}.`);
+  }
+  if (testCase.run) {
+    await testCase.run(exported as (...args: unknown[]) => unknown);
+    return;
+  }
+  let observed = 0;
+  if (testCase.expectedObserved === undefined || !testCase.reducer) {
+    throw new Error(`Missing callback expectations for ${testCase.name}.`);
+  }
+  assertEquals(
+    exported((value: number) => {
+      observed = testCase.reducer === 'weighted' ? observed * 100 + value : value;
+      return value;
+    }),
+    0,
+    testCase.name,
+  );
+  assertEquals(observed, testCase.expectedObserved, testCase.name);
+}
+
+async function main(): Promise<void> {
+  const caseFilter = Deno.env.get('SOUNDSCRIPT_PROMISE_CASE');
+  const caseFiltersValue = Deno.env.get('SOUNDSCRIPT_PROMISE_CASES');
+  const caseFilters = caseFiltersValue ? new Set(JSON.parse(caseFiltersValue) as string[]) : undefined;
+  const cases: PromiseCompilerCase[] = [
+    {
+      name: 'compileProject executes Promise.all over direct fulfilled Promise array literals',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.all([Promise.resolve(20), Promise.resolve(2)])',
+        '    .then((values) => {',
+        '      callback(values[0] + values[1]);',
+        '      return values.length;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject propagates Promise.all rejections from direct Promise array literals',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.all([Promise.resolve(20), Promise.reject<number>(2)])',
+        '    .catch(() => {',
+        '      callback(23);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject executes Promise.race over direct fulfilled Promise array literals',
+      expectedObserved: 20,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.race([Promise.resolve(20), Promise.resolve(2)])',
+        '    .then((value) => {',
+        '      callback(value);',
+        '      return value + 1;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject propagates Promise.race rejections from direct Promise array literals',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.race([Promise.reject<number>(20), Promise.resolve(2)])',
+        '    .catch(() => {',
+        '      callback(23);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name:
+        'compileProject executes Promise.resolve then callbacks before exported functions return',
+      expectedObserved: 21,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.resolve(20).then((value) => {',
+        '    callback(value + 1);',
+        '    return value + 2;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject drains chained Promise.then callbacks before exported functions return',
+      expectedObserved: 25,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.resolve(20)',
+        '    .then((value) => value + 2)',
+        '    .then((value) => {',
+        '      callback(value + 3);',
+        '      return value + 4;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name:
+        'compileProject executes Promise.reject catch callbacks before exported functions return',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.reject(20)',
+        '    .catch(() => 22)',
+        '    .then((value) => {',
+        '      callback(value + 1);',
+        '      return value + 2;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject propagates rejected Promises through then without handlers',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.reject(20)',
+        '    .then()',
+        '    .catch(() => 22)',
+        '    .then((value) => {',
+        '      callback(value + 1);',
+        '      return value + 2;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject adopts Promise values returned from then callbacks',
+      expectedObserved: 25,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.resolve(20)',
+        '    .then((value) => Promise.resolve(value + 2))',
+        '    .then((value) => {',
+        '      callback(value + 3);',
+        '      return value + 4;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject adopts rejected Promise values returned from then callbacks',
+      expectedObserved: 25,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.resolve(20)',
+        '    .then((value) => Promise.reject<number>(value + 2))',
+        '    .catch(() => {',
+        '      callback(25);',
+        '      return 26;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name:
+        'compileProject treats Promise.resolve(existingPromise) as passthrough for fulfilled Promises',
+      expectedObserved: 21,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  const promise = Promise.resolve(20);',
+        '  Promise.resolve(promise)',
+        '    .then((value) => {',
+        '      callback(value + 1);',
+        '      return value + 2;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name:
+        'compileProject treats Promise.resolve(existingPromise) as passthrough for rejected Promises',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  const promise = Promise.reject(20);',
+        '  Promise.resolve(promise)',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 23;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers local async functions that await fulfilled compiler-owned Promises',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    const value = await Promise.resolve(20);',
+        '    return value + 2;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers local async functions with sequential await steps',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    const left = await Promise.resolve(20);',
+        '    const right = await Promise.resolve(2);',
+        '    return left + right;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers straight-line async awaited reassignment through persisted frame locals',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let total = await Promise.resolve(20);',
+        '    total = await Promise.resolve(total + 2);',
+        '    return total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject hoists local function declarations inside local async functions across await boundaries',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    function addTwo(value: number): number {',
+        '      return value + 2;',
+        '    }',
+        '    const value = await Promise.resolve(20);',
+        '    return addTwo(value);',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject propagates rejected await values through local async functions',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    const value = await Promise.reject<number>(20);',
+        '    return value + 2;',
+        '  }',
+        '  compute().catch(() => {',
+        '    callback(23);',
+        '    return 0;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject hoists local function declarations inside exported async functions across await boundaries',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  function addTwo(value: number): number {',
+        '    return value + 2;',
+        '  }',
+        '  const value = await Promise.resolve(20);',
+        '  return addTwo(value);',
+        '}',
+        '',
+      ].join('\n'),
+      async run(exported): Promise<void> {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async function to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers local async arrow functions that await compiler-owned Promises',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  const compute = async (): Promise<number> => {',
+        '    const value = await Promise.resolve(20);',
+        '    return value + 2;',
+        '  };',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers module-scope async helpers used from exported sync functions',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'async function compute(): Promise<number> {',
+        '  const value = await Promise.resolve(20);',
+        '  return value + 2;',
+        '}',
+        '',
+        'export function main(callback: (value: number) => number): number {',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers await on plain fulfilled values inside local async functions',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    const value = await 20;',
+        '    return value + 2;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers async helpers without await by wrapping their return values',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'async function compute(): Promise<number> {',
+        '  return 22;',
+        '}',
+        '',
+        'export function main(callback: (value: number) => number): number {',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/catch around rejected awaits',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      const value = await Promise.reject<number>(20);',
+        '      return value + 2;',
+        '    } catch {',
+        '      return 22;',
+        '    }',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/catch with catch bindings',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      const value = await Promise.reject<string>("boom");',
+        '      return value.length;',
+        '    } catch (error: unknown) {',
+        '      return 22;',
+        '    }',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/finally around fulfilled awaits',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.resolve(20);',
+        '    } finally {',
+        '      callback(2);',
+        '    }',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 2);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/finally around rejected awaits',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.reject<number>(20);',
+        '    } finally {',
+        '      callback(2);',
+        '    }',
+        '  }',
+        '  compute().catch(() => {',
+        '    callback(22);',
+        '    return 0;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/finally with return inside finally',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.resolve(20);',
+        '    } finally {',
+        '      return 22;',
+        '    }',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers final async try/finally with return inside finally after rejection',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.reject<number>(20);',
+        '    } finally {',
+        '      return 22;',
+        '    }',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves non-final async try/finally returns from try bodies',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.resolve(22);',
+        '    } finally {',
+        '      callback(2);',
+        '    }',
+        '    callback(100);',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves non-final async try/finally returns from finally bodies',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      await Promise.resolve(20);',
+        '    } finally {',
+        '      return 22;',
+        '    }',
+        '    callback(100);',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers non-final async try/catch and continues afterward',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let total = 0;',
+        '    try {',
+        '      total = await Promise.reject<number>(20);',
+        '    } catch {',
+        '      total = 20;',
+        '    }',
+        '    return total + 2;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers non-final async try/catch/finally and continues afterward',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let total = 0;',
+        '    try {',
+        '      total = await Promise.reject<number>(20);',
+        '    } catch {',
+        '      total = 20;',
+        '    } finally {',
+        '      total = total + 1;',
+        '    }',
+        '    return total + 1;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves non-final async try/catch returns from catch bodies',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      await Promise.reject<number>(20);',
+        '    } catch {',
+        '      return 22;',
+        '    }',
+        '    callback(100);',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers top-level async if branches with awaited values',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number, flag: boolean): number {',
+        '  async function compute(): Promise<number> {',
+        '    if (flag) {',
+        '      const left = await Promise.resolve(20);',
+        '      return left + 2;',
+        '    }',
+        '    const right = await Promise.resolve(2);',
+        '    return right + 20;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, true),
+          0,
+        );
+        assertEquals(observed, 23);
+        observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, false),
+          0,
+        );
+        assertEquals(observed, 23);
+      },
+    },
+    {
+      name: 'compileProject lowers top-level async if and continues after the branch',
+      expectedObserved: 24,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number, flag: boolean): number {',
+        '  async function compute(): Promise<number> {',
+        '    if (flag) {',
+        '      await Promise.resolve(20);',
+        '    } else {',
+        '      await Promise.resolve(2);',
+        '    }',
+        '    return 23;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, true),
+          0,
+        );
+        assertEquals(observed, 24);
+        observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, false),
+          0,
+        );
+        assertEquals(observed, 24);
+      },
+    },
+    {
+      name: 'compileProject lowers top-level async if with sync fallthrough branch',
+      expectedObserved: 24,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number, flag: boolean): number {',
+        '  async function compute(): Promise<number> {',
+        '    if (flag) {',
+        '      await Promise.resolve(20);',
+        '    }',
+        '    return 23;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, true),
+          0,
+        );
+        assertEquals(observed, 24);
+        observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, false),
+          0,
+        );
+        assertEquals(observed, 24);
+      },
+    },
+    {
+      name: 'compileProject preserves mutable locals across async if branches',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number, flag: boolean): number {',
+        '  async function compute(): Promise<number> {',
+        '    let total = 0;',
+        '    if (flag) {',
+        '      total = await Promise.resolve(20);',
+        '    } else {',
+        '      total = await Promise.resolve(21);',
+        '    }',
+        '    return flag ? total + 2 : total + 1;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, true),
+          0,
+        );
+        assertEquals(observed, 22);
+        observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }, false),
+          0,
+        );
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject preserves mutable locals across async while loops',
+      expectedObserved: 6,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    while (current < 3) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '      current = current + 1;',
+        '    }',
+        '    return total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports top-level async while break statements',
+      expectedObserved: 11,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    while (current < 5) {',
+        '      current = current + 1;',
+        '      const next = await Promise.resolve(current);',
+        '      total = total + next;',
+        '      break;',
+        '    }',
+        '    return current * 10 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports top-level async while continue statements',
+      expectedObserved: 3,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    while (current < 3) {',
+        '      current = current + 1;',
+        '      await Promise.resolve(current);',
+        '      continue;',
+        '      total = total + 100;',
+        '    }',
+        '    return current + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports conditional async while break and continue statements',
+      expectedObserved: 8,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    while (current < 5) {',
+        '      current = current + 1;',
+        '      if (current === 2) {',
+        '        continue;',
+        '      }',
+        '      const next = await Promise.resolve(current);',
+        '      total = total + next;',
+        '      if (current === 4) {',
+        '        break;',
+        '      }',
+        '    }',
+        '    return total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports return statements inside async while loops',
+      expectedObserved: 21,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    while (current < 5) {',
+        '      current = current + 1;',
+        '      const next = await Promise.resolve(current);',
+        '      return next + 20;',
+        '    }',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject bridges exported async functions to host Promises',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  const value = await Promise.resolve(20);',
+        '  return value + 2;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async function to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async while loops with awaited mutable locals',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let current = 0;',
+        '  let total = 0;',
+        '  while (current < 3) {',
+        '    const next = await Promise.resolve(current + 1);',
+        '    total = total + next;',
+        '    current = current + 1;',
+        '  }',
+        '  return total;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async while loop to return a host Promise.');
+        }
+        assertEquals(await result, 6);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async for loops with top-level continue statements',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let current = 0;',
+        '  let total = 0;',
+        '  for (; current < 3; current = current + 1) {',
+        '    await Promise.resolve(current + 1);',
+        '    continue;',
+        '    total = total + 100;',
+        '  }',
+        '  return current + total;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async for loop with continue to return a host Promise.');
+        }
+        assertEquals(await result, 3);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async for let loops with continue statements',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let total = 0;',
+        '  for (let current = 0; current < 3; current = current + 1) {',
+        '    if (current === 1) {',
+        '      continue;',
+        '    }',
+        '    const next = await Promise.resolve(current + 1);',
+        '    total = total + next;',
+        '  }',
+        '  return total;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async for let loop to return a host Promise.');
+        }
+        assertEquals(await result, 4);
+      },
+    },
+    {
+      name: 'compileProject preserves mutable locals across async for loops',
+      expectedObserved: 6,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 3; current = current + 1) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '    }',
+        '    return total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject lowers async for loops with expression initializers',
+      expectedObserved: 6,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (current = 0; current < 3; current = current + 1) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '    }',
+        '    return total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject keeps async for let loop bindings out of later async continuations',
+      expectedObserved: 27,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 20;',
+        '    let total = 0;',
+        '    for (let current = 0; current < 3; current = current + 1) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '    }',
+        '    return current + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports top-level async for break statements',
+      expectedObserved: 1,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '      break;',
+        '    }',
+        '    return current * 10 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports top-level async for continue statements',
+      expectedObserved: 3,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 3; current = current + 1) {',
+        '      await Promise.resolve(current + 1);',
+        '      continue;',
+        '      total = total + 100;',
+        '    }',
+        '    return current + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports conditional async for break and continue statements',
+      expectedObserved: 24,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      if (current === 1) {',
+        '        continue;',
+        '      }',
+        '      const next = await Promise.resolve(current + 1);',
+        '      total = total + next;',
+        '      if (current === 2) {',
+        '        break;',
+        '      }',
+        '    }',
+        '    return current * 10 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves continue completion through async for finally blocks',
+      expectedObserved: 303,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 3; current = current + 1) {',
+        '      try {',
+        '        total = total + 100;',
+        '      } finally {',
+        '        await Promise.resolve(current);',
+        '        continue;',
+        '      }',
+        '      total = total + 1;',
+        '    }',
+        '    return total + current;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves break completion through async for finally blocks',
+      expectedObserved: 100,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      try {',
+        '        total = total + 100;',
+        '      } finally {',
+        '        await Promise.resolve(current);',
+        '        break;',
+        '      }',
+        '      total = total + 1;',
+        '    }',
+        '    return total + current;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves catch bindings through async for try catch continue',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let total = 0;',
+        '    for (; total < 2;) {',
+        '      try {',
+        '        await Promise.reject<string>("boom");',
+        '        total = 100;',
+        '      } catch (error: unknown) {',
+        '        total = total + 1;',
+        '        continue;',
+        '      }',
+        '    }',
+        '    return total + 20;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports return statements inside async for loops',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      const next = await Promise.resolve(current + 1);',
+        '      return next + 21;',
+        '    }',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject supports return statements inside async for finally blocks',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    for (; current < 2; current = current + 1) {',
+        '      try {',
+        '        await Promise.resolve(current + 1);',
+        '      } finally {',
+        '        return 22;',
+        '      }',
+        '    }',
+        '    return 0;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value + 1);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves continue completion through async for try finally',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 2; current = current + 1) {',
+        '      try {',
+        '        await Promise.resolve(current + 1);',
+        '        continue;',
+        '      } finally {',
+        '        total = total + 1;',
+        '      }',
+        '    }',
+        '    return current * 10 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves return completion through exported async for try finally',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let total = 0;',
+        '  for (; total < 1; total = total + 1) {',
+        '    try {',
+        '      const next = await Promise.resolve(20);',
+        '      return next + 1;',
+        '    } finally {',
+        '      total = total + 1;',
+        '    }',
+        '  }',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async for loop with return to return a host Promise.');
+        }
+        assertEquals(await result, 21);
+      },
+    },
+    {
+      name: 'compileProject preserves break completion through async for try finally',
+      expectedObserved: 11,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      try {',
+        '        const next = await Promise.resolve(current + 1);',
+        '        total = total + next;',
+        '        break;',
+        '      } finally {',
+        '        total = total + 10;',
+        '      }',
+        '    }',
+        '    return current * 100 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves continue completion through async for try catch',
+      expectedObserved: 3,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 3; current = current + 1) {',
+        '      try {',
+        '        await Promise.reject<number>(current + 1);',
+        '      } catch {',
+        '        continue;',
+        '      }',
+        '      total = total + 100;',
+        '    }',
+        '    return current + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject preserves break completion through async for try catch',
+      expectedObserved: 7,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    let current = 0;',
+        '    let total = 0;',
+        '    for (; current < 5; current = current + 1) {',
+        '      try {',
+        '        await Promise.reject<number>(current + 1);',
+        '      } catch {',
+        '        total = total + 7;',
+        '        break;',
+        '      }',
+        '      total = total + 100;',
+        '    }',
+        '    return current * 10 + total;',
+        '  }',
+        '  compute().then((value) => {',
+        '    callback(value);',
+        '    return value;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject bridges exported async for loops with awaited mutable locals',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let current = 0;',
+        '  let total = 0;',
+        '  for (; current < 3; current = current + 1) {',
+        '    const next = await Promise.resolve(current + 1);',
+        '    total = total + next;',
+        '  }',
+        '  return total;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async for loop to return a host Promise.');
+        }
+        assertEquals(await result, 6);
+      },
+    },
+    {
+      name: 'compileProject awaits ambient imported host Promise results',
+      source: [
+        'declare function fetchNumber(): Promise<number>;',
+        '',
+        'export async function main(): Promise<number> {',
+        '  return await fetchNumber();',
+        '}',
+        '',
+      ].join('\n'),
+      hostFunctions: {
+        'src/index.ts:fetchNumber': () => Promise.resolve(22),
+      },
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async ambient import to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject catches rejected ambient imported host Promise results',
+      source: [
+        'declare function fetchNumber(): Promise<number>;',
+        '',
+        'export async function main(): Promise<number> {',
+        '  try {',
+        '    return await fetchNumber();',
+        '  } catch {',
+        '    return 22;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      hostFunctions: {
+        'src/index.ts:fetchNumber': () => Promise.reject(20),
+      },
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async ambient import catch to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject awaits ambient imported host Promise results with number params',
+      source: [
+        'declare function fetchNumber(input: number): Promise<number>;',
+        '',
+        'export async function main(): Promise<number> {',
+        '  return await fetchNumber(20);',
+        '}',
+        '',
+      ].join('\n'),
+      hostFunctions: {
+        'src/index.ts:fetchNumber': (input: unknown) => Promise.resolve(Number(input) + 2),
+      },
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async ambient import with params to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject awaits ambient imported host Promise results with string params',
+      source: [
+        'declare function fetchNumber(input: string): Promise<number>;',
+        '',
+        'export async function main(): Promise<number> {',
+        '  return await fetchNumber("20");',
+        '}',
+        '',
+      ].join('\n'),
+      hostFunctions: {
+        'src/index.ts:fetchNumber': (input: unknown) => Promise.resolve(Number(String(input)) + 2),
+      },
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async ambient string import to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject awaits ambient imported host Promise results with Promise params',
+      source: [
+        'declare function fetchNumber(input: Promise<number>): Promise<number>;',
+        '',
+        'export async function main(): Promise<number> {',
+        '  return await fetchNumber(Promise.resolve(20));',
+        '}',
+        '',
+      ].join('\n'),
+      hostFunctions: {
+        'src/index.ts:fetchNumber': async (input: unknown) => Number(await (input as Promise<unknown>)) + 2,
+      },
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async ambient Promise-param import to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject awaits host Promise parameters through exported Promise boundaries',
+      source: [
+        'async function compute(input: Promise<number>): Promise<number> {',
+        '  const value = await input;',
+        '  return value + 2;',
+        '}',
+        '',
+        'export function main(input: Promise<number>): Promise<number> {',
+        '  return compute(input);',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.resolve(20));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported Promise boundary to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject propagates rejected host Promise parameters through exported Promise boundaries',
+      source: [
+        'async function compute(input: Promise<number>): Promise<number> {',
+        '  return await input;',
+        '}',
+        '',
+        'export function main(input: Promise<number>): Promise<number> {',
+        '  return compute(input);',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.reject(20));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported Promise boundary to return a host Promise.');
+        }
+        try {
+          await result;
+          throw new Error('Expected bridged host Promise rejection.');
+        } catch (error) {
+          assertEquals(error, 20);
+        }
+      },
+    },
+    {
+      name: 'compileProject bridges exported async try/catch over host Promise rejections',
+      source: [
+        'export async function main(input: Promise<number>): Promise<number> {',
+        '  try {',
+        '    return await input;',
+        '  } catch {',
+        '    return 22;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.reject(20));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async try/catch to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async try/finally with return inside finally',
+      source: [
+        'export async function main(input: Promise<number>): Promise<number> {',
+        '  try {',
+        '    return await input;',
+        '  } finally {',
+        '    return 22;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.reject(20));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async try/finally to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async try/catch with catch bindings',
+      source: [
+        'export async function main(input: Promise<number>): Promise<number> {',
+        '  try {',
+        '    return await input;',
+        '  } catch (error: unknown) {',
+        '    return 22;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.reject('boom'));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async try/catch to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers async throw statements through compiler-owned Promise rejection',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function run(): Promise<number> {',
+        '    throw new Error("boom");',
+        '  }',
+        '  run()',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async throw statements to host Promise rejection',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  throw new Error("boom");',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async throw to return a host Promise.');
+        }
+        const observed = await result.then(() => 0, () => 22);
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers async throw statements from builtin Error parameters',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function run(reason: Error): Promise<number> {',
+        '    throw reason;',
+        '  }',
+        '  run(new Error("boom"))',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers async throw statements from inferred builtin Error locals',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function run(): Promise<number> {',
+        '    const reason = new Error("boom");',
+        '    throw reason;',
+        '  }',
+        '  run()',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers async throw statements from annotated builtin Error locals',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function run(): Promise<number> {',
+        '    let reason: Error = new Error("boom");',
+        '    throw reason;',
+        '  }',
+        '  run()',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject lowers async catch rethrow after builtin Error instanceof narrowing',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    const rejected: Promise<number> = Promise.reject(new Error("boom"));',
+        '    try {',
+        '      return await rejected;',
+        '    } catch (error: unknown) {',
+        '      if (error instanceof Error) {',
+        '        throw error;',
+        '      }',
+        '      return 21;',
+        '    }',
+        '  }',
+        '  compute().catch(() => {',
+        '    callback(23);',
+        '    return 0;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 23);
+      },
+    },
+    {
+      name: 'compileProject lowers direct await Promise.reject builtin Error catch rethrow',
+      expectedObserved: 23,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  async function compute(): Promise<number> {',
+        '    try {',
+        '      return await Promise.reject(new Error("boom"));',
+        '    } catch (error: unknown) {',
+        '      if (error instanceof Error) {',
+        '        throw error;',
+        '      }',
+        '      return 21;',
+        '    }',
+        '  }',
+        '  compute().catch(() => {',
+        '    callback(23);',
+        '    return 0;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        let observed = 0;
+        assertEquals(
+          exported((value: number) => {
+            observed = value;
+            return value;
+          }),
+          0,
+        );
+        assertEquals(observed, 23);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async builtin Error catch rethrow to host Promise rejection',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  try {',
+        '    return await Promise.reject(new Error("boom"));',
+        '  } catch (error: unknown) {',
+        '    if (error instanceof Error) {',
+        '      throw error;',
+        '    }',
+        '    return 21;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async builtin Error rethrow to return a host Promise.');
+        }
+        const observed = await result.then(() => 0, () => 22);
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges host Promise builtin Error catch rethrow through exported async functions',
+      source: [
+        'export async function main(input: Promise<number>): Promise<number> {',
+        '  try {',
+        '    return await input;',
+        '  } catch (error: unknown) {',
+        '    if (error instanceof Error) {',
+        '      throw error;',
+        '    }',
+        '    return 21;',
+        '  }',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported(Promise.reject(new Error('boom')));
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async host Promise Error rethrow to return a host Promise.');
+        }
+        const observed = await result.then(() => 0, () => 22);
+        assertEquals(observed, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async if branches with awaited mutable locals',
+      source: [
+        'export async function main(flag: boolean): Promise<number> {',
+        '  let total = 0;',
+        '  if (flag) {',
+        '    total = await Promise.resolve(20);',
+        '  } else {',
+        '    total = await Promise.resolve(21);',
+        '  }',
+        '  return flag ? total + 2 : total + 1;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const trueResult = exported(true);
+        if (!(trueResult instanceof Promise)) {
+          throw new Error('Expected exported async if branch to return a host Promise.');
+        }
+        assertEquals(await trueResult, 22);
+        const falseResult = exported(false);
+        if (!(falseResult instanceof Promise)) {
+          throw new Error('Expected exported async if branch to return a host Promise.');
+        }
+        assertEquals(await falseResult, 22);
+      },
+    },
+    {
+      name: 'compileProject bridges exported async non-final try/catch with mutable locals',
+      source: [
+        'export async function main(): Promise<number> {',
+        '  let total = 0;',
+        '  try {',
+        '    total = await Promise.reject<number>(20);',
+        '  } catch {',
+        '    total = 20;',
+        '  }',
+        '  return total + 2;',
+        '}',
+        '',
+      ].join('\n'),
+      run: async (exported) => {
+        const result = exported();
+        if (!(result instanceof Promise)) {
+          throw new Error('Expected exported async try/catch to return a host Promise.');
+        }
+        assertEquals(await result, 22);
+      },
+    },
+    {
+      name:
+        'compileProject executes new Promise executors synchronously and fulfills through resolve',
+      expectedObserved: 122,
+      reducer: 'weighted',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  new Promise<number>((resolve) => {',
+        '    callback(1);',
+        '    resolve(20);',
+        '  }).then((value) => {',
+        '    callback(value + 2);',
+        '    return value + 3;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject rejects through new Promise reject callbacks',
+      expectedObserved: 122,
+      reducer: 'weighted',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  new Promise<number>((_, reject) => {',
+        '    callback(1);',
+        '    reject(20);',
+        '  }).catch(() => {',
+        '    callback(22);',
+        '    return 23;',
+        '  });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject executes Promise.finally callbacks and preserves fulfilled values',
+      expectedObserved: 122,
+      reducer: 'weighted',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.resolve(20)',
+        '    .finally(() => {',
+        '      callback(1);',
+        '    })',
+        '    .then((value) => {',
+        '      callback(value + 2);',
+        '      return value + 3;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject executes Promise.finally callbacks and preserves rejected reasons',
+      expectedObserved: 122,
+      reducer: 'weighted',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  Promise.reject(20)',
+        '    .finally(() => {',
+        '      callback(1);',
+        '    })',
+        '    .catch(() => {',
+        '      callback(22);',
+        '      return 0;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    {
+      name: 'compileProject treats undefined Promise.finally callbacks as passthrough handlers',
+      expectedObserved: 22,
+      reducer: 'last',
+      source: [
+        'export function main(callback: (value: number) => number): number {',
+        '  const cleanup = undefined;',
+        '  Promise.resolve(20)',
+        '    .finally(cleanup)',
+        '    .then((value) => {',
+        '      callback(value + 2);',
+        '      return value + 3;',
+        '    });',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+    },
+  ];
+  if (Deno.env.get('SOUNDSCRIPT_PROMISE_LIST_CASES') === '1') {
+    console.log(JSON.stringify(cases.map((testCase) => testCase.name)));
+    return;
+  }
+
+  for (const testCase of cases) {
+    if (caseFilters && !caseFilters.has(testCase.name)) {
+      continue;
+    }
+    if (caseFilter && !testCase.name.includes(caseFilter)) {
+      continue;
+    }
+    await runPromiseCompilerCase(testCase);
+  }
+}
+
+await main();