streams: use Web IDL "a promise resolved with" semantics for callback results

src/js/builtins/StreamInternals.ts

@@ -31,9 +31,33 @@
   $pokePromiseAsHandled(promise);
 }
 
+// Web IDL "a promise resolved with x" — always a fresh promise (the
+// assimilation hop when x is a thenable is observable in the spec's microtask
+// ordering). Promise.$resolve would return x unchanged when x is already a
+// native Promise and skip that hop; the streams ref-impl explicitly avoids
+// Promise.resolve here for the same reason.
+//
+// $resolvePromise performs thenable assimilation via Get(x, "then") and
+// invokes it when it differs from the builtin, so a monkey-patched
+// Promise.prototype.then is reached. For native promises replicate the
+// PromiseResolveThenableJob timing — queue a job that chains the reaction
+// — through the intrinsic .$then: same two-hop microtask ordering,
+// tamper-proof.
 export function shieldingPromiseResolve(result) {
-  const promise = Promise.$resolve(result);
-  if (promise.$then === undefined) promise.$then = $Promise.prototype.$then;
+  const promise = $newPromise();
+  if ($isPromise(result)) {
+    $enqueueJob(
+      (p, r) =>
+        r.$then(
+          v => $resolvePromise(p, v),
+          e => $rejectPromise(p, e),
+        ),
+      promise,
+      result,
+    );
+  } else {
+    $resolvePromise(promise, result);
+  }
   return promise;
 }
 

src/js/builtins/WritableStreamInternals.ts

@@ -587,7 +587,13 @@ export function writableStreamDefaultControllerStart(controller) {
   const startAlgorithm = $getByIdDirectPrivate(controller, "startAlgorithm");
   $putByIdDirectPrivate(controller, "startAlgorithm", undefined);
   const stream = $getByIdDirectPrivate(controller, "stream");
-  return Promise.$resolve(startAlgorithm.$call()).$then(
+  // Web IDL "a promise resolved with x" is always a fresh promise — when
+  // startAlgorithm() returns one (as TransformStream's does), the assimilation
+  // hop is observable in the spec's microtask ordering. Promise.$resolve would
+  // return the input promise unchanged and skip that hop.
+  // $shieldingPromiseResolve takes the hop via .$then so a monkey-patched
+  // Promise.prototype.then is not reached during assimilation.
+  return $shieldingPromiseResolve(startAlgorithm.$call()).$then(
     () => {
       const state = $getByIdDirectPrivate(stream, "state");
       $assert(state === "writable" || state === "erroring");
@@ -626,7 +632,13 @@ export function setUpWritableStreamDefaultControllerFromUnderlyingSink(
 
   if ("start" in underlyingSinkDict) {
     const startMethod = underlyingSinkDict["start"];
-    startAlgorithm = () => $promiseInvokeOrNoopMethodNoCatch(underlyingSink, startMethod, [controller]);
+    // UnderlyingSinkStartCallback's IDL return type is `any`, so Web IDL
+    // "invoke" performs no promise conversion here. The single "a promise
+    // resolved with startResult" wrap happens in
+    // writableStreamDefaultControllerStart (SetUpWritableStreamDefaultController
+    // step 17). A synchronous throw propagates out of the WritableStream
+    // constructor, matching spec.
+    startAlgorithm = () => startMethod.$call(underlyingSink, controller);
   }
   if ("write" in underlyingSinkDict) {
     const writeMethod = underlyingSinkDict["write"];

test/js/web/streams/streams.test.js

@@ -260,6 +260,64 @@ describe("WritableStream", () => {
     await rs.pipeTo(ws);
     expect(received).toBe("hello world");
   });
+
+  // SetUpWritableStreamDefaultController step 17: "Let startPromise be a
+  // promise resolved with startResult." Web IDL "a promise resolved with x" is
+  // always a fresh promise; when x is a thenable the PromiseResolveThenableJob
+  // hop is observable in microtask ordering. Promise.resolve(x) would return x
+  // unchanged when x is already a native Promise and skip that hop.
+  describe('[[started]] timing (Web IDL "a promise resolved with")', () => {
+    async function observe(sink) {
+      const order = [];
+      const { promise: done, resolve } = Promise.withResolvers();
+      const ws = new WritableStream({
+        ...sink,
+        write() {
+          order.push("write");
+          resolve();
+        },
+      });
+      ws.getWriter().write("x");
+      queueMicrotask(() => {
+        order.push("mt1");
+        queueMicrotask(() => order.push("mt2"));
+      });
+      await done;
+      return order;
+    }
+
+    it("start() returns a fulfilled Promise: write after the assimilation hop", async () => {
+      expect(await observe({ start: () => Promise.resolve() })).toEqual(["mt1", "mt2", "write"]);
+    });
+
+    it("start() returns undefined: write before the first queued microtask (single wrap, no double-wrap regression)", async () => {
+      expect(await observe({ start() {} })).toEqual(["write", "mt1", "mt2"]);
+    });
+
+    it("no start(): write before the first queued microtask", async () => {
+      expect(await observe({})).toEqual(["write", "mt1", "mt2"]);
+    });
+
+    it("TransformStream writable startAlgorithm returns startPromise: transform after the assimilation hop", async () => {
+      const order = [];
+      const { promise: done, resolve } = Promise.withResolvers();
+      const ts = new TransformStream({
+        transform(chunk, controller) {
+          order.push("transform");
+          controller.enqueue(chunk);
+          resolve();
+        },
+      });
+      ts.readable.getReader().read();
+      ts.writable.getWriter().write("x");
+      queueMicrotask(() => {
+        order.push("mt1");
+        queueMicrotask(() => order.push("mt2"));
+      });
+      await done;
+      expect(order).toEqual(["mt1", "mt2", "transform"]);
+    });
+  });
 });
 
 describe("ReadableStream.prototype.tee", () => {