fix: use Promise<Response> for async kit handler return types (#2966)

* fix: use Promise<Response> return type for async kit handlers

When svelte-check adds type annotations to SvelteKit route handlers
(GET, POST, etc.), it was using `Response | Promise<Response>` as the
return type for all functions regardless of whether they were async.

TypeScript requires async functions to return `Promise<T>`, not
`T | Promise<T>` (TS1064). This caused false positives in
`--incremental` mode where tsc runs on the generated files directly.

The fix checks if the function has an async modifier and, if so,
extracts just the `Promise<Response>` part of the return type union.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* style: format sveltekit.ts with prettier

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix async kit handler return types

Updated async kit handler return types to use Promise<Response>.

* style: format changeset

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: use asyncReturnType parameter instead of string splitting

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: MathiasWP

.changeset/forty-tools-cheat.md

@@ -0,0 +1,6 @@
+---
+'svelte-check': patch
+'svelte2tsx': patch
+---
+
+fix: use Promise<Response> for async kit handler return types

packages/svelte-check/test-success/src/routes/$types.d.ts

@@ -1 +1,6 @@
 export type PageData = {};
+export type RequestEvent = {
+    url: URL;
+    request: Request;
+    params: Record<string, string>;
+};

packages/svelte-check/test-success/src/routes/+server.ts

@@ -0,0 +1,8 @@
+export async function GET({ url }) {
+    return new Response(url.pathname);
+}
+
+export async function POST({ request }) {
+    const body = await request.text();
+    return new Response(body, { status: 201 });
+}

packages/svelte2tsx/src/helpers/sveltekit.ts

@@ -283,7 +283,8 @@ function upsertKitRouteFile(
             isTsFile,
             name,
             `import('./$types.js').RequestEvent`,
-            `Response | Promise<Response>`
+            `Response | Promise<Response>`,
+            `Promise<Response>`
         );
     };
     insertApiMethod('GET');
@@ -476,7 +477,8 @@ function addTypeToFunction(
     isTsFile: boolean,
     name: string,
     type: string,
-    returnType?: string
+    returnType?: string,
+    asyncReturnType?: string
 ) {
     const fn = exports.get(name);
     if (fn?.type === 'function' && fn.node.parameters.length === 1 && !fn.hasTypeDefinition) {
@@ -485,11 +487,15 @@ function addTypeToFunction(
             const paramInsertion = surround(!returnType ? `: Parameters<${type}>[0]` : `: ${type}`);
             insert(paramPos, paramInsertion);
             if (!fn.node.type && fn.node.body) {
+                const isAsync =
+                    fn.node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                const effectiveReturnType =
+                    isAsync && asyncReturnType ? asyncReturnType : returnType;
                 const returnPos = ts.isArrowFunction(fn.node)
                     ? fn.node.equalsGreaterThanToken.getStart()
                     : fn.node.body.getStart();
                 const returnInsertion = surround(
-                    !returnType ? `: ReturnType<${type}> ` : `: ${returnType} `
+                    !effectiveReturnType ? `: ReturnType<${type}> ` : `: ${effectiveReturnType} `
                 );
                 insert(returnPos, returnInsertion);
             }

packages/svelte2tsx/test/helpers/index.ts

@@ -71,7 +71,15 @@ describe('Internal Helpers - upsertKitFile', () => {
         upsert(
             '+server.ts',
             `export async function GET(e) {}`,
-            `export async function GET(e: import('./$types.js').RequestEvent) : Response | Promise<Response> {}`
+            `export async function GET(e: import('./$types.js').RequestEvent) : Promise<Response> {}`
+        );
+    });
+
+    it('upserts GET non-async function', () => {
+        upsert(
+            '+server.ts',
+            `export function GET(e) { return new Response(); }`,
+            `export function GET(e: import('./$types.js').RequestEvent) : Response | Promise<Response> { return new Response(); }`
         );
     });