@stacksjs/bun-router 0.0.13 → 0.0.15

package/dist/index.js

@@ -66,7 +66,7 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-1mvtv6jw.js";
+} from "./chunk-j0e7z7hd.js";
 
 // src/auth.ts
 function base64UrlEncode(str) {
@@ -3915,12 +3915,19 @@ function registerFileBasedRouting(RouterClass) {
       async value() {
         if (this._fileRoutesInitialized)
           return;
+        if (!Object.prototype.hasOwnProperty.call(this, "_fileBasedRoutes")) {
+          this._fileBasedRoutes = [];
+        }
         const viewsDir = this._viewsDir || detectViewsDirectory();
         if (!viewsDir) {
           this._fileRoutesInitialized = true;
           return;
         }
         const config2 = this._fileRoutingConfig || {};
+        if (config2.enabled === false) {
+          this._fileRoutesInitialized = true;
+          return;
+        }
         const extensions = config2.extensions || DEFAULT_EXTENSIONS;
         const exclude = config2.exclude || DEFAULT_EXCLUDES;
         if (!hasRoutableFiles(viewsDir, extensions, exclude)) {
@@ -4291,6 +4298,11 @@ class FileStreamHandler {
 }
 
 // src/router/file-streaming.ts
+function closeReadableStreamAfterError(controller, error) {
+  try {
+    controller.close();
+  } catch {}
+}
 function registerFileStreaming(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     streamFile: {
@@ -4390,7 +4402,7 @@ function registerFileStreaming(RouterClass) {
               }
               controller.close();
             } catch (error) {
-              controller.error(error);
+              closeReadableStreamAfterError(controller, error);
             }
           }
         });
@@ -4434,7 +4446,7 @@ function registerFileStreaming(RouterClass) {
               controller.enqueue(encoder.encode("}"));
               controller.close();
             } catch (error) {
-              controller.error(error);
+              closeReadableStreamAfterError(controller, error);
             }
           }
         });
@@ -4482,7 +4494,7 @@ function registerFileStreaming(RouterClass) {
               }
               controller.close();
             } catch (error) {
-              controller.error(error);
+              closeReadableStreamAfterError(controller, error);
             }
           }
         });
@@ -4514,7 +4526,7 @@ function registerFileStreaming(RouterClass) {
               }
               controller.close();
             } catch (error) {
-              controller.error(error);
+              closeReadableStreamAfterError(controller, error);
             }
           }
         });
@@ -8161,12 +8173,10 @@ function registerRouteBuilding(RouterClass) {
               const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
               matchPath(path, url2.pathname, params, constraintsRecord);
               const enhancedReq = this.enhanceRequest(req, params);
-              const middlewareResult = await this.runMiddleware(enhancedReq, [...this.globalMiddleware, ...route.middleware]);
-              if (middlewareResult) {
-                return this.applyModifiedCookies(middlewareResult, enhancedReq);
-              }
-              const response2 = await this.resolveHandler(route.handler, enhancedReq);
-              return this.applyModifiedCookies(response2, enhancedReq);
+              const routeHandlerMiddleware = async (req2, _next) => await this.resolveHandler(route.handler, req2);
+              const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware];
+              const response2 = await this.runMiddleware(enhancedReq, middlewareStack);
+              return this.applyModifiedCookies(response2 ?? new Response("No response from middleware chain", { status: 500 }), enhancedReq);
             };
           } else {
             const methodHandlers = {};
@@ -8178,12 +8188,10 @@ function registerRouteBuilding(RouterClass) {
                 const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
                 matchPath(path, url2.pathname, params, constraintsRecord);
                 const enhancedReq = this.enhanceRequest(req, params);
-                const middlewareResult = await this.runMiddleware(enhancedReq, [...this.globalMiddleware, ...route.middleware]);
-                if (middlewareResult) {
-                  return this.applyModifiedCookies(middlewareResult, enhancedReq);
-                }
-                const response2 = await this.resolveHandler(route.handler, enhancedReq);
-                return this.applyModifiedCookies(response2, enhancedReq);
+                const routeHandlerMiddleware = async (req2, _next) => await this.resolveHandler(route.handler, req2);
+                const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware];
+                const response2 = await this.runMiddleware(enhancedReq, middlewareStack);
+                return this.applyModifiedCookies(response2 ?? new Response("No response from middleware chain", { status: 500 }), enhancedReq);
               };
             }
             bunRoutes[path] = methodHandlers;
@@ -10419,6 +10427,29 @@ class ResponseWithMacros extends Response {
     return responseMacroRegistry.has(name);
   }
 }
+function resolveResponseInit(statusOrInit, headers) {
+  if (typeof statusOrInit === "number")
+    return { status: statusOrInit, mergedHeaders: headers };
+  if (statusOrInit && typeof statusOrInit === "object") {
+    const status = typeof statusOrInit.status === "number" ? statusOrInit.status : 200;
+    let mergedHeaders = headers;
+    if (statusOrInit.headers) {
+      mergedHeaders = {};
+      if (statusOrInit.headers instanceof Headers) {
+        statusOrInit.headers.forEach((value, key) => {
+          mergedHeaders[key] = value;
+        });
+      } else if (Array.isArray(statusOrInit.headers)) {
+        for (const [key, value] of statusOrInit.headers)
+          mergedHeaders[key] = value;
+      } else {
+        Object.assign(mergedHeaders, statusOrInit.headers);
+      }
+    }
+    return { status, mergedHeaders };
+  }
+  return { status: 200, mergedHeaders: headers };
+}
 var BuiltInResponseMacros = {
   success: (data, message, status = 200) => {
     const body = {};
@@ -10496,39 +10527,43 @@ var BuiltInResponseMacros = {
       headers: { "Content-Type": "application/json" }
     });
   },
-  json: (data, status = 200, headers = {}) => {
+  json: (data, statusOrInit = 200, headers = {}) => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers);
     return new Response(JSON.stringify(data), {
       status,
       headers: {
         "Content-Type": "application/json",
-        ...headers
+        ...mergedHeaders
       }
     });
   },
-  html: (content, status = 200, headers = {}) => {
+  html: (content, statusOrInit = 200, headers = {}) => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers);
     return new Response(content, {
       status,
       headers: {
         "Content-Type": "text/html",
-        ...headers
+        ...mergedHeaders
       }
     });
   },
-  text: (content, status = 200, headers = {}) => {
+  text: (content, statusOrInit = 200, headers = {}) => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers);
     return new Response(content, {
       status,
       headers: {
         "Content-Type": "text/plain",
-        ...headers
+        ...mergedHeaders
       }
     });
   },
-  xml: (content, status = 200, headers = {}) => {
+  xml: (content, statusOrInit = 200, headers = {}) => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers);
     return new Response(content, {
       status,
       headers: {
         "Content-Type": "application/xml",
-        ...headers
+        ...mergedHeaders
       }
     });
   },

package/dist/response/macros.d.ts

@@ -144,21 +144,32 @@ export declare const BuiltInResponseMacros: {
         path: string;
     }, message?: string) => Response;
     /**
-     * JSON response with custom headers
+     * JSON response with custom headers. Accepts BOTH the native
+     * `Response.json(data, init?)` shape (where `init` is a
+     * `ResponseInit` object) AND the legacy positional
+     * `Response.json(data, status, headers)` shape. Required for
+     * backwards-compatibility with framework + third-party code that
+     * calls `Response.json(data, { status: 422 })` — the standard WHATWG
+     * signature that Bun's native `Response.json` ships with.
+     *
+     * See stacksjs/stacks#1857.
      */
-    json: (data: any, status?: number, headers?: Record<string, string>) => Response;
+    json: (data: any, statusOrInit?: number | ResponseInit, headers?: Record<string, string>) => Response;
     /**
-     * HTML response
+     * HTML response. Dual-shape: native `(content, init?)` or positional
+     * `(content, status, headers)`.
      */
-    html: (content: string, status?: number, headers?: Record<string, string>) => Response;
+    html: (content: string, statusOrInit?: number | ResponseInit, headers?: Record<string, string>) => Response;
     /**
-     * Plain text response
+     * Plain text response. Dual-shape: native `(content, init?)` or
+     * positional `(content, status, headers)`.
      */
-    text: (content: string, status?: number, headers?: Record<string, string>) => Response;
+    text: (content: string, statusOrInit?: number | ResponseInit, headers?: Record<string, string>) => Response;
     /**
-     * XML response
+     * XML response. Dual-shape: native `(content, init?)` or positional
+     * `(content, status, headers)`.
      */
-    xml: (content: string, status?: number, headers?: Record<string, string>) => Response;
+    xml: (content: string, statusOrInit?: number | ResponseInit, headers?: Record<string, string>) => Response;
     /**
      * Redirect response
      */

package/dist/router/router.d.ts

@@ -99,37 +99,60 @@ export declare class Router {
      */
     resolveMiddleware(middleware: string | MiddlewareHandler): MiddlewareHandler | null;
     /**
-     * HTTP GET method
+     * HTTP GET method.
+     *
+     * `TPath` is inferred from the path literal at the call site, so an
+     * inline handler's `request.params` narrows to the extracted keyset:
+     *
+     * ```ts
+     * router.get('/api/users/{id}', (req) => {
+     *   req.params.id // typed `string`, no `as any`
+     *   // @ts-expect-error wrong key
+     *   req.params.bogus
+     * })
+     * ```
+     *
+     * The string-action / class-handler forms (`'Actions/Foo/BarAction'`)
+     * keep working — `ActionHandler<TPath>` is a union that accepts them.
+     * See stacksjs/stacks#1851 for the broader typed-request work.
      */
-    get(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    get<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * HTTP POST method
+     * HTTP POST method. See {@link get} for `TPath`-driven param
+     * narrowing on inline handlers.
      */
-    post(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    post<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * HTTP PUT method
+     * HTTP PUT method. See {@link get} for `TPath`-driven param
+     * narrowing on inline handlers.
      */
-    put(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    put<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * HTTP PATCH method
+     * HTTP PATCH method. See {@link get} for `TPath`-driven param
+     * narrowing on inline handlers.
      */
-    patch(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    patch<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * HTTP DELETE method
+     * HTTP DELETE method. See {@link get} for `TPath`-driven param
+     * narrowing on inline handlers.
      */
-    delete(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    delete<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * HTTP OPTIONS method
+     * HTTP OPTIONS method. See {@link get} for `TPath`-driven param
+     * narrowing on inline handlers.
      */
-    options(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    options<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * Register route for multiple HTTP methods
+     * Register the same handler against multiple HTTP methods. The
+     * handler is type-narrowed via {@link ActionHandler}'s `TPath`
+     * generic, same as the single-method overloads.
      */
-    match(methods: string[], path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    match<TPath extends string>(methods: string[], path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
-     * Register route for any HTTP method
+     * Register the handler against every HTTP method. See {@link get}
+     * for `TPath`-driven param narrowing on inline handlers.
      */
-    any(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
+    any<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router;
     /**
      * Set fallback handler for unmatched routes
      */

package/dist/types.d.ts

@@ -1716,6 +1716,18 @@ export interface RequestMacroMethods {
     param: <T = InputValue>(key: string, defaultValue?: T) => T;
     cookie: (name: string, defaultValue?: string) => string | null;
     cookies: () => Record<string, string>;
+    /**
+     * Lookup a single uploaded file by form field name. Returns the
+     * matching `FileInfo` (structurally an `UploadedFile`) or `null` when
+     * no field with that name was uploaded. Populated by the multipart
+     * file-upload middleware alongside `files: UploadedFile[]`. Mirrors
+     * Laravel's `$request->file('avatar')`:
+     *
+     * ```ts
+     * const avatar = req.file('avatar')
+     * if (!avatar) return new Response('Missing avatar', { status: 400 })
+     * ```
+     */
     file: (name: string) => FileInfo | null;
     hasFile: (name: string) => boolean;
     path: () => string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -73,8 +73,8 @@
     "zip:windows-x64": "zip -j bin/router-windows-x64.zip bin/router-windows-x64.exe",
     "zip:darwin-x64": "zip -j bin/router-darwin-x64.zip bin/router-darwin-x64",
     "zip:darwin-arm64": "zip -j bin/router-darwin-arm64.zip bin/router-darwin-arm64",
-    "lint": "bunx --bun eslint .",
-    "lint:fix": "bunx --bun eslint . --fix",
+    "lint": "bunx --bun pickier .",
+    "lint:fix": "bunx --bun pickier . --fix",
     "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
     "changelog": "bunx changelogen --output CHANGELOG.md",
     "prepublishOnly": "bun --bun run build",
@@ -86,8 +86,5 @@
   "dependencies": {
     "@stacksjs/clapp": "^0.2.0",
     "ts-rate-limiter": "^0.4.2"
-  },
-  "lint-staged": {
-    "*.{js,ts}": "bunx --bun pickier . --fix"
   }
 }

package/src/middleware/auth.ts

@@ -58,7 +58,8 @@ export function extractBasicAuth(authHeader: string): { username: string, passwo
     return { username, password }
   }
   catch (error) {
-    console.error(error)
+    void error
+
     return null
   }
 }

package/src/middleware/file_upload.ts

@@ -162,6 +162,17 @@ export default class FileUpload {
         configurable: true,
       })
 
+      // Typed lookup by form field name. Mirrors Laravel's
+      // `$request->file('avatar')` ergonomics: returns the matching
+      // UploadedFile or null. See stacksjs/stacks#1856.
+      Object.defineProperty(req, 'file', {
+        value: (fieldName: string): UploadedFile | null =>
+          uploadedFiles.find(f => f.fieldName === fieldName) ?? null,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      })
+
       Object.defineProperty(req, 'formBody', {
         value: fields,
         writable: true,

package/src/response/macros.ts

@@ -124,6 +124,44 @@ export class ResponseWithMacros extends Response {
   }
 }
 
+/**
+ * Reconcile the second argument of `Response.<method>(body, statusOrInit, headers?)`.
+ * Accepts either a positional status number (legacy bun-router shape) or a
+ * `ResponseInit` object (native WHATWG shape `{ status?, headers?, statusText? }`).
+ * When a `ResponseInit` provides `headers`, those replace the positional `headers`
+ * arg entirely — matching the principle that the more-explicit form wins.
+ *
+ * Headers normalize to a plain string map so downstream spread works uniformly.
+ */
+function resolveResponseInit(
+  statusOrInit: number | ResponseInit,
+  headers: Record<string, string>,
+): { status: number, mergedHeaders: Record<string, string> } {
+  if (typeof statusOrInit === 'number')
+    return { status: statusOrInit, mergedHeaders: headers }
+
+  if (statusOrInit && typeof statusOrInit === 'object') {
+    const status = typeof statusOrInit.status === 'number' ? statusOrInit.status : 200
+    let mergedHeaders = headers
+    if (statusOrInit.headers) {
+      mergedHeaders = {}
+      if (statusOrInit.headers instanceof Headers) {
+        statusOrInit.headers.forEach((value, key) => { mergedHeaders[key] = value })
+      }
+      else if (Array.isArray(statusOrInit.headers)) {
+        for (const [key, value] of statusOrInit.headers)
+          mergedHeaders[key] = value
+      }
+      else {
+        Object.assign(mergedHeaders, statusOrInit.headers as Record<string, string>)
+      }
+    }
+    return { status, mergedHeaders }
+  }
+
+  return { status: 200, mergedHeaders: headers }
+}
+
 /**
  * Built-in response macros
  */
@@ -274,53 +312,68 @@ export const BuiltInResponseMacros = {
   },
 
   /**
-   * JSON response with custom headers
+   * JSON response with custom headers. Accepts BOTH the native
+   * `Response.json(data, init?)` shape (where `init` is a
+   * `ResponseInit` object) AND the legacy positional
+   * `Response.json(data, status, headers)` shape. Required for
+   * backwards-compatibility with framework + third-party code that
+   * calls `Response.json(data, { status: 422 })` — the standard WHATWG
+   * signature that Bun's native `Response.json` ships with.
+   *
+   * See stacksjs/stacks#1857.
    */
-  json: (data: any, status = 200, headers: Record<string, string> = {}): Response => {
+  json: (data: any, statusOrInit: number | ResponseInit = 200, headers: Record<string, string> = {}): Response => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers)
     return new Response(JSON.stringify(data), {
       status,
       headers: {
         'Content-Type': 'application/json',
-        ...headers,
+        ...mergedHeaders,
       },
     })
   },
 
   /**
-   * HTML response
+   * HTML response. Dual-shape: native `(content, init?)` or positional
+   * `(content, status, headers)`.
    */
-  html: (content: string, status = 200, headers: Record<string, string> = {}): Response => {
+  html: (content: string, statusOrInit: number | ResponseInit = 200, headers: Record<string, string> = {}): Response => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers)
     return new Response(content, {
       status,
       headers: {
         'Content-Type': 'text/html',
-        ...headers,
+        ...mergedHeaders,
       },
     })
   },
 
   /**
-   * Plain text response
+   * Plain text response. Dual-shape: native `(content, init?)` or
+   * positional `(content, status, headers)`.
    */
-  text: (content: string, status = 200, headers: Record<string, string> = {}): Response => {
+  text: (content: string, statusOrInit: number | ResponseInit = 200, headers: Record<string, string> = {}): Response => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers)
     return new Response(content, {
       status,
       headers: {
         'Content-Type': 'text/plain',
-        ...headers,
+        ...mergedHeaders,
       },
     })
   },
 
   /**
-   * XML response
+   * XML response. Dual-shape: native `(content, init?)` or positional
+   * `(content, status, headers)`.
    */
-  xml: (content: string, status = 200, headers: Record<string, string> = {}): Response => {
+  xml: (content: string, statusOrInit: number | ResponseInit = 200, headers: Record<string, string> = {}): Response => {
+    const { status, mergedHeaders } = resolveResponseInit(statusOrInit, headers)
     return new Response(content, {
       status,
       headers: {
         'Content-Type': 'application/xml',
-        ...headers,
+        ...mergedHeaders,
       },
     })
   },

package/src/router/file-based-routing.ts

@@ -488,6 +488,16 @@ export function registerFileBasedRouting(RouterClass: typeof Router): void {
       async value(): Promise<void> {
         if (this._fileRoutesInitialized) return
 
+        // Ensure each Router instance gets its OWN routes array. The
+        // `_fileBasedRoutes: { value: [] }` declaration on the prototype
+        // means every instance shares a single array reference until
+        // someone reassigns. Without this lazy-init, calls like
+        // `instanceA.getFileRoutes()` leak routes registered by
+        // `instanceB._initFileRoutes()` — cross-instance contamination.
+        if (!Object.prototype.hasOwnProperty.call(this, '_fileBasedRoutes')) {
+          this._fileBasedRoutes = []
+        }
+
         // Auto-detect views directory if not configured
         const viewsDir = this._viewsDir || detectViewsDirectory()
         if (!viewsDir) {
@@ -496,6 +506,16 @@ export function registerFileBasedRouting(RouterClass: typeof Router): void {
         }
 
         const config = this._fileRoutingConfig || {}
+
+        // Honour the opt-out flag set by `router.disableFileRouting()` and by
+        // anyone passing `{ enabled: false }` to `router.views(...)`. Before
+        // this check the flag was stored but never read, so the public
+        // `disableFileRouting()` API silently did nothing.
+        if (config.enabled === false) {
+          this._fileRoutesInitialized = true
+          return
+        }
+
         const extensions = config.extensions || DEFAULT_EXTENSIONS
         const exclude = config.exclude || DEFAULT_EXCLUDES
 

package/src/router/file-streaming.ts

@@ -5,6 +5,17 @@ import type {
 import type { Router } from './router'
 import { FileStreamHandler, StreamHandler } from '../streaming/stream-handler'
 
+function closeReadableStreamAfterError(controller: ReadableStreamDefaultController, error: unknown): void {
+  void error
+
+  try {
+    controller.close()
+  }
+  catch {
+    // The stream may already be closed or errored by the runtime.
+  }
+}
+
 /**
  * File streaming extension for Router class
  */
@@ -169,7 +180,7 @@ export function registerFileStreaming(RouterClass: typeof Router): void {
               controller.close()
             }
             catch (error) {
-              controller.error(error)
+              closeReadableStreamAfterError(controller, error)
             }
           },
         })
@@ -233,7 +244,7 @@ export function registerFileStreaming(RouterClass: typeof Router): void {
               controller.close()
             }
             catch (error) {
-              controller.error(error)
+              closeReadableStreamAfterError(controller, error)
             }
           },
         })
@@ -294,7 +305,7 @@ export function registerFileStreaming(RouterClass: typeof Router): void {
               controller.close()
             }
             catch (error) {
-              controller.error(error)
+              closeReadableStreamAfterError(controller, error)
             }
           },
         })
@@ -340,7 +351,7 @@ export function registerFileStreaming(RouterClass: typeof Router): void {
               controller.close()
             }
             catch (error) {
-              controller.error(error)
+              closeReadableStreamAfterError(controller, error)
             }
           },
         })