{"version":3,"file":"index.cjs","names":["AbstractHandlerAdapterService","AbstractBunHandlerAdapterService","createArgumentGetters","handlerMetadata","config","getters","querySchema","schema","push","target","request","url","URL","params","parse","Object","fromEntries","searchParams","requestSchema","data","json","hasUrlParams","urlParams","buildHeaders","context","headers","key","value","entries","String","AbstractBunHandlerAdapterService","Injectable","InjectionToken","BunStreamAdapterToken","create","Symbol","for","token","BunStreamAdapterService","createStaticHandler","boundMethod","formatArguments","context","headersTemplate","buildHeaders","handleStreamResult","createStreamResultHandler","streamWriter","createStreamWriter","isStatic","handler","wrapWithErrorHandling","request","argument","result","createDynamicHandler","resolution","methodName","scoped","controllerInstance","resolve","write","_data","end","Response","key","value","Object","entries","headers","set","status","statusCode","AbstractBunHandlerAdapterService","Injectable","InjectionToken","BunEndpointAdapterToken","create","Symbol","for","token","BunEndpointAdapterService","hasSchema","handlerMetadata","config","options","validateResponses","responseSchema","provideSchema","_handlerMetadata","buildHeaders","context","headers","createStaticHandler","boundMethod","formatArguments","formatResponse","buildResponseFormatter","statusCode","isStatic","handler","wrapWithErrorHandling","request","argument","result","Response","JSON","stringify","status","createDynamicHandler","resolution","methodName","scoped","controllerInstance","resolve","shouldValidate","parse","BunEndpointAdapterService","Injectable","InjectionToken","BunMultipartAdapterToken","create","Symbol","for","token","BunMultipartAdapterService","createArgumentGetters","handlerMetadata","config","getters","querySchema","schema","push","target","request","url","URL","params","parse","Object","fromEntries","searchParams","hasUrlParams","urlParams","requestSchema","formData","formDataObject","parseFormData","data","result","key","value","entries","Array","isArray","BunExecutionContext","module","controller","handler","request","reply","getModule","getController","getHandler","getRequest","Error","getReply","BunFakeReply","_statusCode","_body","_sent","_headers","status","code","send","body","header","name","value","hasResponse","getStatusCode","getBody","toResponse","headers","JSON","stringify","Response","reset","initializer","util.jsonStringifyReplacer","error","core.formatError","core.flattenError","util.jsonStringifyReplacer","issues","core.$constructor","simpleHash","str","hash","i","length","char","charCodeAt","Math","abs","toString","generateTokenId","name","customId","base","split","InjectionToken","id","formattedName","schema","create","bound","token","value","BoundInjectionToken","factory","FactoryInjectionToken","refineType","className","resolved","resolve","ctx","Registry","factories","Map","highestPriority","parent","has","token","id","get","factory","Error","toString","getAll","records","length","sort","a","b","priority","set","scope","target","type","record","originalToken","existing","push","currentHighest","delete","deletedHighest","remaining","filter","r","newHighest","reduce","max","current","updateScope","forEach","highest","globalRegistry","InjectableScope","InjectableType","InjectableTokenMeta","InjectionToken","globalRegistry","Injectable","scope","Singleton","token","schema","registry","priority","target","context","kind","Function","Error","injectableToken","create","set","Class","InjectionToken","BunControllerAdapterToken","create","InjectionToken","BunRequestToken","create","InjectionToken","BunServerToken","create","InjectionToken","BunApplicationServiceToken","create","DEFAULT_METHODS","matchOrigin","requestOrigin","origin","RegExp","test","Array","isArray","entry","result","Promise","resolve","error","allow","normalizeToString","value","join","calculateCorsHeaders","options","allowedOrigin","credentials","Error","headers","Vary","exposedHeaders","calculatePreflightHeaders","requestMethod","requestHeaders","baseHeaders","methods","allowedHeaders","maxAge","undefined","String","cacheControl","isPreflight","method","accessControlRequestMethod","applyCorsToResponse","response","corsHeaders","Headers","key","Object","entries","set","Response","body","status","statusText","Container","ErrorResponseProducerService","ExecutionContext","extractControllerMetadata","FrameworkError","generateRequestId","GuardRunnerService","HttpException","inject","Injectable","InstanceResolverService","Logger","runWithRequestId","ZodError","BunExecutionContext","BunFakeReply","BunControllerAdapterToken","BunRequestToken","applyCorsToResponse","token","BunControllerAdapterService","guardRunner","container","instanceResolver","errorProducer","logger","context","name","setupController","controller","routes","moduleMetadata","globalPrefix","corsOptions","controllerMetadata","endpoint","endpoints","classMethod","url","httpMethod","adapterToken","Error","adapter","get","guards","makeContext","guardResolution","resolveMany","Array","from","reverse","fullUrl","replaceAll","wrapHandler","provideHandler","debug","handlerResult","hasGuards","classTypes","length","isStatic","request","origin","headers","response","handler","error","errorResponse","handleError","cached","fakeReply","executionContext","canActivate","runGuardsStatic","instances","hasResponse","toResponse","Response","status","Set","requestId","requestContainer","beginRequest","addInstance","runGuards","endRequest","catch","err","message","JSON","stringify","statusCode","respond","ValidationError","handleUnknown","payload","Container","ErrorResponseProducerService","FrameworkError","inject","Injectable","Logger","BunApplicationServiceToken","BunControllerAdapterToken","BunServerToken","applyCorsToResponse","calculatePreflightHeaders","isPreflight","token","BunApplicationService","logger","context","name","container","errorProducer","server","controllerAdapter","globalPrefix","routes","serverOptions","corsOptions","configureOptions","setupAdapter","options","mergedOptions","initServer","addInstance","ready","setGlobalPrefix","prefix","getGlobalPrefix","getServer","Error","onModulesInit","modules","_moduleName","moduleMetadata","controllers","size","controller","setupController","handleRequest","request","origin","headers","get","accessControlRequestMethod","method","requestHeaders","preflightHeaders","undefined","Response","status","errorResponse","respond","NotFound","url","response","JSON","stringify","payload","statusCode","enableCors","enableMultipart","listen","port","hostname","Bun","serve","fetch","bind","log","configure","dispose","stop","AdapterToken","EndpointAdapterToken","HttpAdapterToken","MultipartAdapterToken","Request","StreamAdapterToken","BunEndpointAdapterService","BunMultipartAdapterService","BunStreamAdapterService","BunApplicationService","BunRequestToken","defineBunEnvironment","tokens","Map"],"sources":["../src/adapters/abstract-bun-handler-adapter.service.mts","../src/adapters/stream-adapter.service.mts","../src/adapters/endpoint-adapter.service.mts","../src/adapters/multipart-adapter.service.mts","../src/interfaces/bun-execution-context.interface.mts","../src/interfaces/bun-fake-reply.interface.mts","../../../node_modules/zod/v4/core/core.js","../../../node_modules/zod/v4/core/util.js","../../../node_modules/zod/v4/core/errors.js","../../../node_modules/zod/v4/classic/errors.js","../../src/enums/injectable-scope.enum.mts","../../src/enums/injectable-type.enum.mts","../../src/symbols/injectable-token.mts","../../src/token/injection-token.mts","../../src/token/registry.mts","../../src/decorators/injectable.decorator.mts","../src/tokens/controller-adapter.token.mts","../src/tokens/request.token.mts","../src/tokens/server.token.mts","../src/tokens/bun-application.token.mts","../src/utils/cors.util.mts","../src/services/controller-adapter.service.mts","../src/services/application.service.mts","../src/define-environment.mts"],"sourcesContent":["import type { BaseEndpointOptions } from '@navios/builder'\nimport type { HandlerMetadata } from '@navios/core'\nimport type { BunRequest } from 'bun'\n\nimport {\n AbstractHandlerAdapterService,\n type ArgumentGetter,\n type HandlerContext,\n} from '@navios/core'\n\n/**\n * Abstract base class for Bun handler adapters.\n *\n * Provides shared argument parsing logic for Bun:\n * - Query parameters via URL parsing\n * - Request body via request.json()\n * - URL parameters via request.params\n *\n * Concrete adapters (Endpoint, Stream) implement response handling\n * via createStaticHandler and createDynamicHandler.\n *\n * @typeParam TConfig - Endpoint configuration type\n */\nexport abstract class AbstractBunHandlerAdapterService<\n TConfig extends BaseEndpointOptions = BaseEndpointOptions,\n> extends AbstractHandlerAdapterService {\n /**\n * Creates argument getters for Bun request parsing.\n *\n * Handles:\n * - Query params: Parses URL search params with schema validation\n * - Request body: Parses JSON body with schema validation\n * - URL params: Extracts route parameters from request.params\n */\n protected override createArgumentGetters(\n handlerMetadata: HandlerMetadata,\n ): ArgumentGetter[] {\n const config = handlerMetadata.config\n const getters: ArgumentGetter[] = []\n\n if (config.querySchema) {\n const schema = config.querySchema\n getters.push((target, request) => {\n const url = new URL(request.url)\n target.params = schema.parse(Object.fromEntries(url.searchParams))\n })\n }\n\n if (config.requestSchema) {\n const schema = config.requestSchema\n getters.push(async (target, request) => {\n target.data = schema.parse(await request.json())\n })\n }\n\n if (this.hasUrlParams(config)) {\n getters.push((target, request) => {\n target.urlParams = request.params\n })\n }\n\n return getters\n }\n\n /**\n * Builds response headers from context.\n * Can be overridden by concrete adapters to add Content-Type, etc.\n */\n protected buildHeaders(\n context: HandlerContext,\n ): Record {\n const headers: Record = {}\n for (const [key, value] of Object.entries(context.headers)) {\n headers[key] = String(value)\n }\n return headers\n }\n}\n","import type { BaseEndpointOptions } from '@navios/builder'\nimport type {\n AbstractDynamicHandler,\n AbstractStaticHandler,\n FormatArgumentsFn,\n HandlerContext,\n InstanceResolution,\n} from '@navios/core'\nimport type { BunRequest } from 'bun'\n\nimport { Injectable, InjectionToken } from '@navios/core'\n\nimport { AbstractBunHandlerAdapterService } from './abstract-bun-handler-adapter.service.mjs'\n\n/**\n * Injection token for the Bun stream adapter service.\n *\n * This token is used to inject the `BunStreamAdapterService` instance\n * into the dependency injection container.\n */\nexport const BunStreamAdapterToken =\n InjectionToken.create(\n Symbol.for('BunStreamAdapterService'),\n )\n\n/**\n * Adapter service for handling streaming requests and responses in Bun.\n *\n * This service extends `AbstractBunHandlerAdapterService` and provides\n * handling for stream-based endpoints. Handlers receive a streamWriter\n * stub and can return Response objects directly for streaming.\n *\n * @extends {AbstractBunHandlerAdapterService}\n *\n * @example\n * ```ts\n * // Used automatically when defining endpoints with @Stream()\n * @Controller()\n * class StreamController {\n * @Stream(streamEvents)\n * async streamData(data: StreamDto) {\n * // Returns a Response object for streaming\n * return new Response(stream, {\n * headers: { 'Content-Type': 'text/event-stream' },\n * })\n * }\n * }\n * ```\n */\n@Injectable({\n token: BunStreamAdapterToken,\n})\nexport class BunStreamAdapterService extends AbstractBunHandlerAdapterService {\n /**\n * Creates a static handler for singleton controllers.\n *\n * Passes a streamWriter stub as the second argument to the controller method.\n *\n * @param boundMethod - Pre-bound controller method\n * @param formatArguments - Function to format request arguments\n * @param context - Handler context with metadata\n * @returns Static handler result\n */\n protected override createStaticHandler(\n boundMethod: (...args: any[]) => Promise,\n formatArguments: FormatArgumentsFn,\n context: HandlerContext,\n ): AbstractStaticHandler {\n const headersTemplate = this.buildHeaders(context)\n const handleStreamResult = this.createStreamResultHandler(\n context,\n headersTemplate,\n )\n const streamWriter = this.createStreamWriter()\n\n return {\n isStatic: true,\n handler: this.wrapWithErrorHandling(async (request: BunRequest) => {\n const argument = await formatArguments(request)\n const result = await boundMethod(argument, streamWriter)\n return handleStreamResult(result)\n }),\n }\n }\n\n /**\n * Creates a dynamic handler for request-scoped controllers.\n *\n * Passes a streamWriter stub as the second argument to the controller method.\n *\n * @param resolution - Instance resolution with resolve function\n * @param formatArguments - Function to format request arguments\n * @param context - Handler context with metadata\n * @returns Dynamic handler result\n */\n protected override createDynamicHandler(\n resolution: InstanceResolution,\n formatArguments: FormatArgumentsFn,\n context: HandlerContext,\n ): AbstractDynamicHandler {\n const headersTemplate = this.buildHeaders(context)\n const handleStreamResult = this.createStreamResultHandler(\n context,\n headersTemplate,\n )\n const streamWriter = this.createStreamWriter()\n const { methodName } = context\n\n return {\n isStatic: false,\n handler: this.wrapWithErrorHandling(\n async (scoped, request: BunRequest) => {\n const controllerInstance = (await resolution.resolve(scoped)) as any\n const argument = await formatArguments(request)\n const result = await controllerInstance[methodName](\n argument,\n streamWriter,\n )\n return handleStreamResult(result)\n },\n ),\n }\n }\n\n /**\n * Creates a stream writer stub for Bun.\n */\n protected createStreamWriter() {\n return {\n write: (_data: any) => {},\n end: () => {},\n }\n }\n\n /**\n * Creates a handler for stream results.\n *\n * If the result is a Response, adds custom headers.\n * Otherwise, wraps the result in a new Response.\n */\n protected createStreamResultHandler(\n context: HandlerContext,\n headersTemplate: Record,\n ) {\n return (result: any) => {\n if (result instanceof Response) {\n for (const [key, value] of Object.entries(headersTemplate)) {\n result.headers.set(key, value)\n }\n return result\n }\n return new Response(result, {\n status: context.statusCode,\n headers: headersTemplate,\n })\n }\n }\n}\n","import type { EndpointOptions } from '@navios/builder'\nimport type {\n AbstractDynamicHandler,\n AbstractStaticHandler,\n FormatArgumentsFn,\n HandlerContext,\n HandlerMetadata,\n InstanceResolution,\n} from '@navios/core'\nimport type { BunRequest } from 'bun'\n\nimport { Injectable, InjectionToken } from '@navios/core'\n\nimport { AbstractBunHandlerAdapterService } from './abstract-bun-handler-adapter.service.mjs'\n\n/**\n * Injection token for the Bun endpoint adapter service.\n *\n * This token is used to inject the `BunEndpointAdapterService` instance\n * into the dependency injection container.\n */\nexport const BunEndpointAdapterToken =\n InjectionToken.create(\n Symbol.for('BunEndpointAdapterService'),\n )\n\n/**\n * Adapter service for handling standard REST endpoint requests in Bun.\n *\n * This service extends `AbstractBunHandlerAdapterService` and provides specialized\n * handling for REST endpoints with request/response schema validation.\n * It automatically parses request bodies, query parameters, and URL parameters,\n * validates them against Zod schemas, and formats responses according to\n * response schemas.\n *\n * @extends {AbstractBunHandlerAdapterService}\n *\n * @example\n * ```ts\n * // Used automatically when defining endpoints with @Endpoint()\n * @Controller()\n * class UserController {\n * @Endpoint({\n * method: 'POST',\n * url: '/users',\n * requestSchema: createUserSchema,\n * responseSchema: userSchema,\n * })\n * async createUser(data: CreateUserDto) {\n * // data is validated against createUserSchema\n * return { id: 1, ...data } // Response validated against userSchema\n * }\n * }\n * ```\n */\n@Injectable({\n token: BunEndpointAdapterToken,\n})\nexport class BunEndpointAdapterService extends AbstractBunHandlerAdapterService {\n /**\n * Checks if the handler has any validation schemas defined.\n *\n * @param handlerMetadata - The handler metadata containing configuration.\n * @returns `true` if the handler has request, query, or response schemas.\n */\n override hasSchema(\n handlerMetadata: HandlerMetadata,\n ): boolean {\n const config = handlerMetadata.config\n return (\n super.hasSchema(handlerMetadata) ||\n (!!this.options.validateResponses && !!config.responseSchema)\n )\n }\n\n /**\n * Provides schema information for the handler.\n *\n * For Bun adapter, this returns an empty object as Bun doesn't require\n * schema registration like some other frameworks.\n *\n * @param _handlerMetadata - The handler metadata containing configuration.\n * @returns An empty schema object.\n */\n override provideSchema(\n _handlerMetadata: HandlerMetadata,\n ): Record {\n return {}\n }\n\n /**\n * Builds response headers with Content-Type: application/json.\n */\n protected override buildHeaders(\n context: HandlerContext,\n ): Record {\n const headers = super.buildHeaders(context)\n headers['Content-Type'] = 'application/json'\n return headers\n }\n\n /**\n * Creates a static handler for singleton controllers.\n *\n * @param boundMethod - Pre-bound controller method\n * @param formatArguments - Function to format request arguments\n * @param context - Handler context with metadata\n * @returns Static handler result\n */\n protected override createStaticHandler(\n boundMethod: (...args: any[]) => Promise,\n formatArguments: FormatArgumentsFn,\n context: HandlerContext,\n ): AbstractStaticHandler {\n const headers = this.buildHeaders(context)\n const formatResponse = this.buildResponseFormatter(context)\n const { statusCode } = context\n\n return {\n isStatic: true,\n handler: this.wrapWithErrorHandling(async (request: BunRequest) => {\n const argument = await formatArguments(request)\n const result = await boundMethod(argument)\n return new Response(JSON.stringify(formatResponse(result)), {\n status: statusCode,\n headers,\n })\n }),\n }\n }\n\n /**\n * Creates a dynamic handler for request-scoped controllers.\n *\n * @param resolution - Instance resolution with resolve function\n * @param formatArguments - Function to format request arguments\n * @param context - Handler context with metadata\n * @returns Dynamic handler result\n */\n protected override createDynamicHandler(\n resolution: InstanceResolution,\n formatArguments: FormatArgumentsFn,\n context: HandlerContext,\n ): AbstractDynamicHandler {\n const headers = this.buildHeaders(context)\n const formatResponse = this.buildResponseFormatter(context)\n const { statusCode, methodName } = context\n\n return {\n isStatic: false,\n handler: this.wrapWithErrorHandling(\n async (scoped, request: BunRequest) => {\n const controllerInstance = (await resolution.resolve(scoped)) as any\n const argument = await formatArguments(request)\n const result = await controllerInstance[methodName](argument)\n return new Response(JSON.stringify(formatResponse(result)), {\n status: statusCode,\n headers,\n })\n },\n ),\n }\n }\n\n /**\n * Builds a response formatter with optional schema validation.\n */\n protected buildResponseFormatter(context: HandlerContext) {\n const responseSchema = context.handlerMetadata.config.responseSchema\n const shouldValidate = this.options.validateResponses !== false\n\n return responseSchema && shouldValidate\n ? (result: any) => responseSchema.parse(result)\n : (result: any) => result\n }\n}\n","import type { EndpointOptions } from '@navios/builder'\nimport type { ArgumentGetter, HandlerMetadata } from '@navios/core'\nimport type { BunRequest } from 'bun'\n\nimport { Injectable, InjectionToken } from '@navios/core'\n\nimport { BunEndpointAdapterService } from './endpoint-adapter.service.mjs'\n\n/**\n * Injection token for the Bun multipart adapter service.\n *\n * This token is used to inject the `BunMultipartAdapterService` instance\n * into the dependency injection container.\n */\nexport const BunMultipartAdapterToken =\n InjectionToken.create(\n Symbol.for('BunMultipartAdapterService'),\n )\n\n/**\n * Adapter service for handling multipart/form-data requests in Bun.\n *\n * This service extends `BunEndpointAdapterService` and provides specialized\n * handling for file uploads and multipart form data. It automatically parses\n * FormData objects, handles file uploads, and validates the data against\n * Zod schemas.\n *\n * @extends {BunEndpointAdapterService}\n *\n * @example\n * ```ts\n * // Used automatically when defining endpoints with @Multipart()\n * @Controller()\n * class UploadController {\n * @Multipart({\n * method: 'POST',\n * url: '/upload',\n * requestSchema: uploadSchema,\n * })\n * async uploadFile(data: UploadDto) {\n * // data contains parsed form fields and File objects\n * return { success: true }\n * }\n * }\n * ```\n */\n@Injectable({\n token: BunMultipartAdapterToken,\n})\nexport class BunMultipartAdapterService extends BunEndpointAdapterService {\n /**\n * Creates argument getters for parsing multipart form data.\n *\n * This method creates an array of functions that extract and validate\n * data from multipart requests, including:\n * - Query parameters\n * - URL parameters\n * - Form fields and file uploads from FormData\n *\n * Files are preserved as File objects, and form fields are parsed and\n * validated against the request schema.\n *\n * @param handlerMetadata - The handler metadata with schemas and configuration.\n * @returns An array of getter functions that populate request arguments.\n */\n protected override createArgumentGetters(\n handlerMetadata: HandlerMetadata,\n ): ArgumentGetter[] {\n const config = handlerMetadata.config\n const getters: ArgumentGetter[] = []\n\n // Handle query parameters\n if (config.querySchema) {\n const schema = config.querySchema\n getters.push((target, request) => {\n const url = new URL(request.url)\n target.params = schema.parse(Object.fromEntries(url.searchParams))\n })\n }\n\n // Handle URL parameters\n if (this.hasUrlParams(config)) {\n getters.push((target, request) => {\n target.urlParams = request.params\n })\n }\n\n // Handle multipart form data\n if (config.requestSchema) {\n const schema = config.requestSchema\n getters.push(async (target, request) => {\n const formData = await request.formData()\n const formDataObject = this.parseFormData(formData)\n target.data = schema.parse(formDataObject)\n })\n }\n\n return getters\n }\n\n /**\n * Parses FormData into a plain object with array support for multiple values.\n */\n private parseFormData(formData: FormData): Record {\n const result: Record = {}\n\n for (const [key, value] of formData.entries()) {\n if (result[key]) {\n if (Array.isArray(result[key])) {\n result[key].push(value)\n } else {\n result[key] = [result[key], value]\n }\n } else {\n result[key] = value\n }\n }\n\n return result\n }\n}\n","import type {\n AbstractExecutionContext,\n ControllerMetadata,\n HandlerMetadata,\n ModuleMetadata,\n} from '@navios/core'\n\nimport type { BunFakeReply } from './bun-fake-reply.interface.mjs'\n\n/**\n * Execution context for Bun adapter requests.\n *\n * This class provides access to metadata about the current request's\n * module, controller, handler, and request object. It's used by guards,\n * interceptors, and other request-scoped services to access context\n * information.\n *\n * @implements {AbstractExecutionContext}\n *\n * @example\n * ```ts\n * @Injectable()\n * class AuthGuard implements CanActivate {\n * canActivate(context: BunExecutionContext): boolean {\n * const request = context.getRequest()\n * const handler = context.getHandler()\n * // Check authentication based on handler metadata\n * return true\n * }\n * }\n * ```\n */\nexport class BunExecutionContext implements AbstractExecutionContext {\n constructor(\n private readonly module: ModuleMetadata,\n private readonly controller: ControllerMetadata,\n private readonly handler: HandlerMetadata,\n private readonly request: Request,\n private readonly reply?: BunFakeReply,\n ) {}\n\n /**\n * Gets the module metadata for the current request.\n *\n * @returns The module metadata containing module configuration and dependencies.\n */\n getModule(): ModuleMetadata {\n return this.module\n }\n\n /**\n * Gets the controller metadata for the current request.\n *\n * @returns The controller metadata containing controller configuration.\n */\n getController(): ControllerMetadata {\n return this.controller\n }\n\n /**\n * Gets the handler metadata for the current request.\n *\n * @returns The handler metadata containing endpoint configuration, schemas, and method information.\n */\n getHandler(): HandlerMetadata {\n return this.handler\n }\n\n /**\n * Gets the current HTTP request object.\n *\n * @returns The Bun Request object for the current request.\n * @throws {Error} If the request is not set.\n */\n getRequest(): Request {\n if (!this.request) {\n throw new Error(\n '[Navios] Request is not set. Make sure to set it before using it.',\n )\n }\n return this.request\n }\n\n /**\n * Gets the reply object for this execution context.\n *\n * In the Bun adapter, this returns a `BunFakeReply` object that collects\n * response information from guards and middleware. The collected information\n * can be used to construct a Response object after guards run.\n *\n * @returns The BunFakeReply object if one was provided, otherwise throws.\n * @throws {Error} If no reply was set in the execution context.\n */\n getReply(): BunFakeReply {\n if (!this.reply) {\n throw new Error(\n '[Navios] Reply is not set. Make sure to set it before using it.',\n )\n }\n return this.reply\n }\n}\n","/**\n * A fake reply object for the Bun adapter that collects response information.\n *\n * Since Bun uses the standard Web API Response object instead of a mutable reply,\n * this class provides a way to capture status and body information from guards\n * and other middleware that expect a reply object with `.status().send()` interface.\n *\n * After guards run, the collected information can be used to construct a Response object.\n *\n * @example\n * ```ts\n * const fakeReply = new BunFakeReply()\n * const context = new BunExecutionContext(module, controller, handler, request, fakeReply)\n *\n * await guardRunner.runGuards(guards, context, container)\n *\n * if (fakeReply.hasResponse()) {\n * return fakeReply.toResponse()\n * }\n * // Continue with normal request handling...\n * ```\n */\nexport class BunFakeReply {\n private _statusCode: number = 200\n private _body: unknown = null\n private _sent: boolean = false\n private _headers: Record = {}\n\n /**\n * Sets the HTTP status code for the response.\n * Returns `this` for chaining.\n *\n * @param code - The HTTP status code.\n * @returns This instance for method chaining.\n */\n status(code: number): this {\n this._statusCode = code\n return this\n }\n\n /**\n * Sets the response body and marks the response as sent.\n *\n * @param body - The response body (will be JSON stringified if not a string).\n */\n send(body: unknown): void {\n this._body = body\n this._sent = true\n }\n\n /**\n * Sets a response header.\n * Returns `this` for chaining.\n *\n * @param name - The header name.\n * @param value - The header value.\n * @returns This instance for method chaining.\n */\n header(name: string, value: string): this {\n this._headers[name] = value\n return this\n }\n\n /**\n * Checks if a response has been sent via this fake reply.\n *\n * @returns `true` if `send()` was called, `false` otherwise.\n */\n hasResponse(): boolean {\n return this._sent\n }\n\n /**\n * Gets the collected status code.\n */\n getStatusCode(): number {\n return this._statusCode\n }\n\n /**\n * Gets the collected body.\n */\n getBody(): unknown {\n return this._body\n }\n\n /**\n * Converts the collected information into a Web API Response object.\n *\n * @returns A Response object with the collected status, body, and headers.\n */\n toResponse(): Response {\n const headers: Record = { ...this._headers }\n\n // Set Content-Type if not already set and body is an object\n if (!headers['Content-Type'] && typeof this._body === 'object') {\n headers['Content-Type'] = 'application/json'\n }\n\n const body =\n typeof this._body === 'string' ? this._body : JSON.stringify(this._body)\n\n return new Response(body, {\n status: this._statusCode,\n headers,\n })\n }\n\n /**\n * Resets the fake reply to its initial state.\n * Useful for reusing the same instance.\n */\n reset(): void {\n this._statusCode = 200\n this._body = null\n this._sent = false\n this._headers = {}\n }\n}\n","/** A special constant with type `never` */\nexport const NEVER = Object.freeze({\n status: \"aborted\",\n});\nexport /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer, params) {\n function init(inst, def) {\n if (!inst._zod) {\n Object.defineProperty(inst, \"_zod\", {\n value: {\n def,\n constr: _,\n traits: new Set(),\n },\n enumerable: false,\n });\n }\n if (inst._zod.traits.has(name)) {\n return;\n }\n inst._zod.traits.add(name);\n initializer(inst, def);\n // support prototype modifications\n const proto = _.prototype;\n const keys = Object.keys(proto);\n for (let i = 0; i < keys.length; i++) {\n const k = keys[i];\n if (!(k in inst)) {\n inst[k] = proto[k].bind(inst);\n }\n }\n }\n // doesn't work if Parent has a constructor with arguments\n const Parent = params?.Parent ?? Object;\n class Definition extends Parent {\n }\n Object.defineProperty(Definition, \"name\", { value: name });\n function _(def) {\n var _a;\n const inst = params?.Parent ? new Definition() : this;\n init(inst, def);\n (_a = inst._zod).deferred ?? (_a.deferred = []);\n for (const fn of inst._zod.deferred) {\n fn();\n }\n return inst;\n }\n Object.defineProperty(_, \"init\", { value: init });\n Object.defineProperty(_, Symbol.hasInstance, {\n value: (inst) => {\n if (params?.Parent && inst instanceof params.Parent)\n return true;\n return inst?._zod?.traits?.has(name);\n },\n });\n Object.defineProperty(_, \"name\", { value: name });\n return _;\n}\n////////////////////////////// UTILITIES ///////////////////////////////////////\nexport const $brand = Symbol(\"zod_brand\");\nexport class $ZodAsyncError extends Error {\n constructor() {\n super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n }\n}\nexport class $ZodEncodeError extends Error {\n constructor(name) {\n super(`Encountered unidirectional transform during encode: ${name}`);\n this.name = \"ZodEncodeError\";\n }\n}\nexport const globalConfig = {};\nexport function config(newConfig) {\n if (newConfig)\n Object.assign(globalConfig, newConfig);\n return globalConfig;\n}\n","// functions\nexport function assertEqual(val) {\n return val;\n}\nexport function assertNotEqual(val) {\n return val;\n}\nexport function assertIs(_arg) { }\nexport function assertNever(_x) {\n throw new Error(\"Unexpected value in exhaustive check\");\n}\nexport function assert(_) { }\nexport function getEnumValues(entries) {\n const numericValues = Object.values(entries).filter((v) => typeof v === \"number\");\n const values = Object.entries(entries)\n .filter(([k, _]) => numericValues.indexOf(+k) === -1)\n .map(([_, v]) => v);\n return values;\n}\nexport function joinValues(array, separator = \"|\") {\n return array.map((val) => stringifyPrimitive(val)).join(separator);\n}\nexport function jsonStringifyReplacer(_, value) {\n if (typeof value === \"bigint\")\n return value.toString();\n return value;\n}\nexport function cached(getter) {\n const set = false;\n return {\n get value() {\n if (!set) {\n const value = getter();\n Object.defineProperty(this, \"value\", { value });\n return value;\n }\n throw new Error(\"cached value already set\");\n },\n };\n}\nexport function nullish(input) {\n return input === null || input === undefined;\n}\nexport function cleanRegex(source) {\n const start = source.startsWith(\"^\") ? 1 : 0;\n const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n return source.slice(start, end);\n}\nexport function floatSafeRemainder(val, step) {\n const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n const stepString = step.toString();\n let stepDecCount = (stepString.split(\".\")[1] || \"\").length;\n if (stepDecCount === 0 && /\\d?e-\\d?/.test(stepString)) {\n const match = stepString.match(/\\d?e-(\\d?)/);\n if (match?.[1]) {\n stepDecCount = Number.parseInt(match[1]);\n }\n }\n const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n const valInt = Number.parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n const stepInt = Number.parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n return (valInt % stepInt) / 10 ** decCount;\n}\nconst EVALUATING = Symbol(\"evaluating\");\nexport function defineLazy(object, key, getter) {\n let value = undefined;\n Object.defineProperty(object, key, {\n get() {\n if (value === EVALUATING) {\n // Circular reference detected, return undefined to break the cycle\n return undefined;\n }\n if (value === undefined) {\n value = EVALUATING;\n value = getter();\n }\n return value;\n },\n set(v) {\n Object.defineProperty(object, key, {\n value: v,\n // configurable: true,\n });\n // object[key] = v;\n },\n configurable: true,\n });\n}\nexport function objectClone(obj) {\n return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));\n}\nexport function assignProp(target, prop, value) {\n Object.defineProperty(target, prop, {\n value,\n writable: true,\n enumerable: true,\n configurable: true,\n });\n}\nexport function mergeDefs(...defs) {\n const mergedDescriptors = {};\n for (const def of defs) {\n const descriptors = Object.getOwnPropertyDescriptors(def);\n Object.assign(mergedDescriptors, descriptors);\n }\n return Object.defineProperties({}, mergedDescriptors);\n}\nexport function cloneDef(schema) {\n return mergeDefs(schema._zod.def);\n}\nexport function getElementAtPath(obj, path) {\n if (!path)\n return obj;\n return path.reduce((acc, key) => acc?.[key], obj);\n}\nexport function promiseAllObject(promisesObj) {\n const keys = Object.keys(promisesObj);\n const promises = keys.map((key) => promisesObj[key]);\n return Promise.all(promises).then((results) => {\n const resolvedObj = {};\n for (let i = 0; i < keys.length; i++) {\n resolvedObj[keys[i]] = results[i];\n }\n return resolvedObj;\n });\n}\nexport function randomString(length = 10) {\n const chars = \"abcdefghijklmnopqrstuvwxyz\";\n let str = \"\";\n for (let i = 0; i < length; i++) {\n str += chars[Math.floor(Math.random() * chars.length)];\n }\n return str;\n}\nexport function esc(str) {\n return JSON.stringify(str);\n}\nexport function slugify(input) {\n return input\n .toLowerCase()\n .trim()\n .replace(/[^\\w\\s-]/g, \"\")\n .replace(/[\\s_-]+/g, \"-\")\n .replace(/^-+|-+$/g, \"\");\n}\nexport const captureStackTrace = (\"captureStackTrace\" in Error ? Error.captureStackTrace : (..._args) => { });\nexport function isObject(data) {\n return typeof data === \"object\" && data !== null && !Array.isArray(data);\n}\nexport const allowsEval = cached(() => {\n // @ts-ignore\n if (typeof navigator !== \"undefined\" && navigator?.userAgent?.includes(\"Cloudflare\")) {\n return false;\n }\n try {\n const F = Function;\n new F(\"\");\n return true;\n }\n catch (_) {\n return false;\n }\n});\nexport function isPlainObject(o) {\n if (isObject(o) === false)\n return false;\n // modified constructor\n const ctor = o.constructor;\n if (ctor === undefined)\n return true;\n if (typeof ctor !== \"function\")\n return true;\n // modified prototype\n const prot = ctor.prototype;\n if (isObject(prot) === false)\n return false;\n // ctor doesn't have static `isPrototypeOf`\n if (Object.prototype.hasOwnProperty.call(prot, \"isPrototypeOf\") === false) {\n return false;\n }\n return true;\n}\nexport function shallowClone(o) {\n if (isPlainObject(o))\n return { ...o };\n if (Array.isArray(o))\n return [...o];\n return o;\n}\nexport function numKeys(data) {\n let keyCount = 0;\n for (const key in data) {\n if (Object.prototype.hasOwnProperty.call(data, key)) {\n keyCount++;\n }\n }\n return keyCount;\n}\nexport const getParsedType = (data) => {\n const t = typeof data;\n switch (t) {\n case \"undefined\":\n return \"undefined\";\n case \"string\":\n return \"string\";\n case \"number\":\n return Number.isNaN(data) ? \"nan\" : \"number\";\n case \"boolean\":\n return \"boolean\";\n case \"function\":\n return \"function\";\n case \"bigint\":\n return \"bigint\";\n case \"symbol\":\n return \"symbol\";\n case \"object\":\n if (Array.isArray(data)) {\n return \"array\";\n }\n if (data === null) {\n return \"null\";\n }\n if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n return \"promise\";\n }\n if (typeof Map !== \"undefined\" && data instanceof Map) {\n return \"map\";\n }\n if (typeof Set !== \"undefined\" && data instanceof Set) {\n return \"set\";\n }\n if (typeof Date !== \"undefined\" && data instanceof Date) {\n return \"date\";\n }\n // @ts-ignore\n if (typeof File !== \"undefined\" && data instanceof File) {\n return \"file\";\n }\n return \"object\";\n default:\n throw new Error(`Unknown data type: ${t}`);\n }\n};\nexport const propertyKeyTypes = new Set([\"string\", \"number\", \"symbol\"]);\nexport const primitiveTypes = new Set([\"string\", \"number\", \"bigint\", \"boolean\", \"symbol\", \"undefined\"]);\nexport function escapeRegex(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n// zod-specific utils\nexport function clone(inst, def, params) {\n const cl = new inst._zod.constr(def ?? inst._zod.def);\n if (!def || params?.parent)\n cl._zod.parent = inst;\n return cl;\n}\nexport function normalizeParams(_params) {\n const params = _params;\n if (!params)\n return {};\n if (typeof params === \"string\")\n return { error: () => params };\n if (params?.message !== undefined) {\n if (params?.error !== undefined)\n throw new Error(\"Cannot specify both `message` and `error` params\");\n params.error = params.message;\n }\n delete params.message;\n if (typeof params.error === \"string\")\n return { ...params, error: () => params.error };\n return params;\n}\nexport function createTransparentProxy(getter) {\n let target;\n return new Proxy({}, {\n get(_, prop, receiver) {\n target ?? (target = getter());\n return Reflect.get(target, prop, receiver);\n },\n set(_, prop, value, receiver) {\n target ?? (target = getter());\n return Reflect.set(target, prop, value, receiver);\n },\n has(_, prop) {\n target ?? (target = getter());\n return Reflect.has(target, prop);\n },\n deleteProperty(_, prop) {\n target ?? (target = getter());\n return Reflect.deleteProperty(target, prop);\n },\n ownKeys(_) {\n target ?? (target = getter());\n return Reflect.ownKeys(target);\n },\n getOwnPropertyDescriptor(_, prop) {\n target ?? (target = getter());\n return Reflect.getOwnPropertyDescriptor(target, prop);\n },\n defineProperty(_, prop, descriptor) {\n target ?? (target = getter());\n return Reflect.defineProperty(target, prop, descriptor);\n },\n });\n}\nexport function stringifyPrimitive(value) {\n if (typeof value === \"bigint\")\n return value.toString() + \"n\";\n if (typeof value === \"string\")\n return `\"${value}\"`;\n return `${value}`;\n}\nexport function optionalKeys(shape) {\n return Object.keys(shape).filter((k) => {\n return shape[k]._zod.optin === \"optional\" && shape[k]._zod.optout === \"optional\";\n });\n}\nexport const NUMBER_FORMAT_RANGES = {\n safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],\n int32: [-2147483648, 2147483647],\n uint32: [0, 4294967295],\n float32: [-3.4028234663852886e38, 3.4028234663852886e38],\n float64: [-Number.MAX_VALUE, Number.MAX_VALUE],\n};\nexport const BIGINT_FORMAT_RANGES = {\n int64: [/* @__PURE__*/ BigInt(\"-9223372036854775808\"), /* @__PURE__*/ BigInt(\"9223372036854775807\")],\n uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt(\"18446744073709551615\")],\n};\nexport function pick(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".pick() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = {};\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n newShape[key] = currDef.shape[key];\n }\n assignProp(this, \"shape\", newShape); // self-caching\n return newShape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function omit(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".omit() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = { ...schema._zod.def.shape };\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n delete newShape[key];\n }\n assignProp(this, \"shape\", newShape); // self-caching\n return newShape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function extend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to extend: expected a plain object\");\n }\n const checks = schema._zod.def.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n // Only throw if new shape overlaps with existing shape\n // Use getOwnPropertyDescriptor to check key existence without accessing values\n const existingShape = schema._zod.def.shape;\n for (const key in shape) {\n if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {\n throw new Error(\"Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.\");\n }\n }\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n });\n return clone(schema, def);\n}\nexport function safeExtend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to safeExtend: expected a plain object\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n });\n return clone(schema, def);\n}\nexport function merge(a, b) {\n const def = mergeDefs(a._zod.def, {\n get shape() {\n const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n get catchall() {\n return b._zod.def.catchall;\n },\n checks: [], // delete existing checks\n });\n return clone(a, def);\n}\nexport function partial(Class, schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".partial() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in oldShape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n // if (oldShape[key]!._zod.optin === \"optional\") continue;\n shape[key] = Class\n ? new Class({\n type: \"optional\",\n innerType: oldShape[key],\n })\n : oldShape[key];\n }\n }\n else {\n for (const key in oldShape) {\n // if (oldShape[key]!._zod.optin === \"optional\") continue;\n shape[key] = Class\n ? new Class({\n type: \"optional\",\n innerType: oldShape[key],\n })\n : oldShape[key];\n }\n }\n assignProp(this, \"shape\", shape); // self-caching\n return shape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function required(Class, schema, mask) {\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n // overwrite with non-optional\n shape[key] = new Class({\n type: \"nonoptional\",\n innerType: oldShape[key],\n });\n }\n }\n else {\n for (const key in oldShape) {\n // overwrite with non-optional\n shape[key] = new Class({\n type: \"nonoptional\",\n innerType: oldShape[key],\n });\n }\n }\n assignProp(this, \"shape\", shape); // self-caching\n return shape;\n },\n });\n return clone(schema, def);\n}\n// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom\nexport function aborted(x, startIndex = 0) {\n if (x.aborted === true)\n return true;\n for (let i = startIndex; i < x.issues.length; i++) {\n if (x.issues[i]?.continue !== true) {\n return true;\n }\n }\n return false;\n}\nexport function prefixIssues(path, issues) {\n return issues.map((iss) => {\n var _a;\n (_a = iss).path ?? (_a.path = []);\n iss.path.unshift(path);\n return iss;\n });\n}\nexport function unwrapMessage(message) {\n return typeof message === \"string\" ? message : message?.message;\n}\nexport function finalizeIssue(iss, ctx, config) {\n const full = { ...iss, path: iss.path ?? [] };\n // for backwards compatibility\n if (!iss.message) {\n const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??\n unwrapMessage(ctx?.error?.(iss)) ??\n unwrapMessage(config.customError?.(iss)) ??\n unwrapMessage(config.localeError?.(iss)) ??\n \"Invalid input\";\n full.message = message;\n }\n // delete (full as any).def;\n delete full.inst;\n delete full.continue;\n if (!ctx?.reportInput) {\n delete full.input;\n }\n return full;\n}\nexport function getSizableOrigin(input) {\n if (input instanceof Set)\n return \"set\";\n if (input instanceof Map)\n return \"map\";\n // @ts-ignore\n if (input instanceof File)\n return \"file\";\n return \"unknown\";\n}\nexport function getLengthableOrigin(input) {\n if (Array.isArray(input))\n return \"array\";\n if (typeof input === \"string\")\n return \"string\";\n return \"unknown\";\n}\nexport function parsedType(data) {\n const t = typeof data;\n switch (t) {\n case \"number\": {\n return Number.isNaN(data) ? \"nan\" : \"number\";\n }\n case \"object\": {\n if (data === null) {\n return \"null\";\n }\n if (Array.isArray(data)) {\n return \"array\";\n }\n const obj = data;\n if (obj && Object.getPrototypeOf(obj) !== Object.prototype && \"constructor\" in obj && obj.constructor) {\n return obj.constructor.name;\n }\n }\n }\n return t;\n}\nexport function issue(...args) {\n const [iss, input, inst] = args;\n if (typeof iss === \"string\") {\n return {\n message: iss,\n code: \"custom\",\n input,\n inst,\n };\n }\n return { ...iss };\n}\nexport function cleanEnum(obj) {\n return Object.entries(obj)\n .filter(([k, _]) => {\n // return true if NaN, meaning it's not a number, thus a string key\n return Number.isNaN(Number.parseInt(k, 10));\n })\n .map((el) => el[1]);\n}\n// Codec utility functions\nexport function base64ToUint8Array(base64) {\n const binaryString = atob(base64);\n const bytes = new Uint8Array(binaryString.length);\n for (let i = 0; i < binaryString.length; i++) {\n bytes[i] = binaryString.charCodeAt(i);\n }\n return bytes;\n}\nexport function uint8ArrayToBase64(bytes) {\n let binaryString = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binaryString += String.fromCharCode(bytes[i]);\n }\n return btoa(binaryString);\n}\nexport function base64urlToUint8Array(base64url) {\n const base64 = base64url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const padding = \"=\".repeat((4 - (base64.length % 4)) % 4);\n return base64ToUint8Array(base64 + padding);\n}\nexport function uint8ArrayToBase64url(bytes) {\n return uint8ArrayToBase64(bytes).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n}\nexport function hexToUint8Array(hex) {\n const cleanHex = hex.replace(/^0x/, \"\");\n if (cleanHex.length % 2 !== 0) {\n throw new Error(\"Invalid hex string length\");\n }\n const bytes = new Uint8Array(cleanHex.length / 2);\n for (let i = 0; i < cleanHex.length; i += 2) {\n bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);\n }\n return bytes;\n}\nexport function uint8ArrayToHex(bytes) {\n return Array.from(bytes)\n .map((b) => b.toString(16).padStart(2, \"0\"))\n .join(\"\");\n}\n// instanceof\nexport class Class {\n constructor(..._args) { }\n}\n","import { $constructor } from \"./core.js\";\nimport * as util from \"./util.js\";\nconst initializer = (inst, def) => {\n inst.name = \"$ZodError\";\n Object.defineProperty(inst, \"_zod\", {\n value: inst._zod,\n enumerable: false,\n });\n Object.defineProperty(inst, \"issues\", {\n value: def,\n enumerable: false,\n });\n inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);\n Object.defineProperty(inst, \"toString\", {\n value: () => inst.message,\n enumerable: false,\n });\n};\nexport const $ZodError = $constructor(\"$ZodError\", initializer);\nexport const $ZodRealError = $constructor(\"$ZodError\", initializer, { Parent: Error });\nexport function flattenError(error, mapper = (issue) => issue.message) {\n const fieldErrors = {};\n const formErrors = [];\n for (const sub of error.issues) {\n if (sub.path.length > 0) {\n fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];\n fieldErrors[sub.path[0]].push(mapper(sub));\n }\n else {\n formErrors.push(mapper(sub));\n }\n }\n return { formErrors, fieldErrors };\n}\nexport function formatError(error, mapper = (issue) => issue.message) {\n const fieldErrors = { _errors: [] };\n const processError = (error) => {\n for (const issue of error.issues) {\n if (issue.code === \"invalid_union\" && issue.errors.length) {\n issue.errors.map((issues) => processError({ issues }));\n }\n else if (issue.code === \"invalid_key\") {\n processError({ issues: issue.issues });\n }\n else if (issue.code === \"invalid_element\") {\n processError({ issues: issue.issues });\n }\n else if (issue.path.length === 0) {\n fieldErrors._errors.push(mapper(issue));\n }\n else {\n let curr = fieldErrors;\n let i = 0;\n while (i < issue.path.length) {\n const el = issue.path[i];\n const terminal = i === issue.path.length - 1;\n if (!terminal) {\n curr[el] = curr[el] || { _errors: [] };\n }\n else {\n curr[el] = curr[el] || { _errors: [] };\n curr[el]._errors.push(mapper(issue));\n }\n curr = curr[el];\n i++;\n }\n }\n }\n };\n processError(error);\n return fieldErrors;\n}\nexport function treeifyError(error, mapper = (issue) => issue.message) {\n const result = { errors: [] };\n const processError = (error, path = []) => {\n var _a, _b;\n for (const issue of error.issues) {\n if (issue.code === \"invalid_union\" && issue.errors.length) {\n // regular union error\n issue.errors.map((issues) => processError({ issues }, issue.path));\n }\n else if (issue.code === \"invalid_key\") {\n processError({ issues: issue.issues }, issue.path);\n }\n else if (issue.code === \"invalid_element\") {\n processError({ issues: issue.issues }, issue.path);\n }\n else {\n const fullpath = [...path, ...issue.path];\n if (fullpath.length === 0) {\n result.errors.push(mapper(issue));\n continue;\n }\n let curr = result;\n let i = 0;\n while (i < fullpath.length) {\n const el = fullpath[i];\n const terminal = i === fullpath.length - 1;\n if (typeof el === \"string\") {\n curr.properties ?? (curr.properties = {});\n (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });\n curr = curr.properties[el];\n }\n else {\n curr.items ?? (curr.items = []);\n (_b = curr.items)[el] ?? (_b[el] = { errors: [] });\n curr = curr.items[el];\n }\n if (terminal) {\n curr.errors.push(mapper(issue));\n }\n i++;\n }\n }\n }\n };\n processError(error);\n return result;\n}\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n * issues: [\n * {\n * expected: 'string',\n * code: 'invalid_type',\n * path: [ 'username' ],\n * message: 'Invalid input: expected string'\n * },\n * {\n * expected: 'number',\n * code: 'invalid_type',\n * path: [ 'favoriteNumbers', 1 ],\n * message: 'Invalid input: expected number'\n * }\n * ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n * ✖ Expected number, received string at \"username\n * favoriteNumbers[0]\n * ✖ Invalid input: expected number\n * ```\n */\nexport function toDotPath(_path) {\n const segs = [];\n const path = _path.map((seg) => (typeof seg === \"object\" ? seg.key : seg));\n for (const seg of path) {\n if (typeof seg === \"number\")\n segs.push(`[${seg}]`);\n else if (typeof seg === \"symbol\")\n segs.push(`[${JSON.stringify(String(seg))}]`);\n else if (/[^\\w$]/.test(seg))\n segs.push(`[${JSON.stringify(seg)}]`);\n else {\n if (segs.length)\n segs.push(\".\");\n segs.push(seg);\n }\n }\n return segs.join(\"\");\n}\nexport function prettifyError(error) {\n const lines = [];\n // sort by path length\n const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);\n // Process each issue\n for (const issue of issues) {\n lines.push(`✖ ${issue.message}`);\n if (issue.path?.length)\n lines.push(` → at ${toDotPath(issue.path)}`);\n }\n // Convert Map to formatted string\n return lines.join(\"\\n\");\n}\n","import * as core from \"../core/index.js\";\nimport { $ZodError } from \"../core/index.js\";\nimport * as util from \"../core/util.js\";\nconst initializer = (inst, issues) => {\n $ZodError.init(inst, issues);\n inst.name = \"ZodError\";\n Object.defineProperties(inst, {\n format: {\n value: (mapper) => core.formatError(inst, mapper),\n // enumerable: false,\n },\n flatten: {\n value: (mapper) => core.flattenError(inst, mapper),\n // enumerable: false,\n },\n addIssue: {\n value: (issue) => {\n inst.issues.push(issue);\n inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);\n },\n // enumerable: false,\n },\n addIssues: {\n value: (issues) => {\n inst.issues.push(...issues);\n inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);\n },\n // enumerable: false,\n },\n isEmpty: {\n get() {\n return inst.issues.length === 0;\n },\n // enumerable: false,\n },\n });\n // Object.defineProperty(inst, \"isEmpty\", {\n // get() {\n // return inst.issues.length === 0;\n // },\n // });\n};\nexport const ZodError = core.$constructor(\"ZodError\", initializer);\nexport const ZodRealError = core.$constructor(\"ZodError\", initializer, {\n Parent: Error,\n});\n// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */\n// export type ErrorMapCtx = core.$ZodErrorMapCtx;\n","export enum InjectableScope {\n /**\n * Singleton scope: The instance is created once and shared across the application.\n */\n Singleton = 'Singleton',\n /**\n * Instance scope: A new instance is created for each injection.\n */\n Transient = 'Transient',\n /**\n * Request scope: The instance is created once per request and shared within that request context.\n */\n Request = 'Request',\n}\n\n","export enum InjectableType {\n Class = 'Class',\n Factory = 'Factory',\n}\n\n","export const InjectableTokenMeta = /* #__PURE__ */ Symbol.for(\n 'InjectableTokenMeta',\n)\n","import type { z, ZodObject, ZodOptional, ZodRecord } from 'zod/v4'\n\nimport type { FactoryContext } from '../internal/context/factory-context.mjs'\n\nexport type ClassType = new (...args: any[]) => any\nexport type ClassTypeWithoutArguments = new () => any\nexport type ClassTypeWithArgument = new (arg: Arg) => any\nexport type ClassTypeWithOptionalArgument = new (arg?: Arg) => any\n\nexport type ClassTypeWithInstance = new (...args: any[]) => T\nexport type ClassTypeWithInstanceAndArgument = new (arg: Arg) => T\nexport type ClassTypeWithInstanceAndOptionalArgument = new (\n arg?: Arg,\n) => T\n\nexport type BaseInjectionTokenSchemaType = ZodObject | ZodRecord\n\nexport type OptionalInjectionTokenSchemaType =\n | ZodOptional\n | ZodOptional\n\nexport type InjectionTokenSchemaType =\n | BaseInjectionTokenSchemaType\n | OptionalInjectionTokenSchemaType\n\n/**\n * Simple hash function for deterministic ID generation\n */\nfunction simpleHash(str: string): string {\n let hash = 0\n for (let i = 0; i < str.length; i++) {\n const char = str.charCodeAt(i)\n hash = (hash << 5) - hash + char\n hash = hash & hash // Convert to 32-bit integer\n }\n return Math.abs(hash).toString(36)\n}\n\n/**\n * Generate deterministic ID from token name\n */\nfunction generateTokenId(name: string | symbol | ClassType, customId?: string): string {\n if (customId) {\n return customId\n }\n\n let base: string\n if (typeof name === 'function') {\n base = `${name.name}_${name.toString()}`\n } else if (typeof name === 'symbol') {\n base = `symbol_${name.toString()}`\n } else {\n base = `token_${name}`\n }\n\n return `${base.split('_')[0]}_${simpleHash(base)}`\n}\n\nexport class InjectionToken<\n // oxlint-disable-next-line no-unused-vars\n T,\n S extends InjectionTokenSchemaType | unknown = unknown,\n // oxlint-disable-next-line no-unused-vars\n Required extends boolean = S extends ZodOptional\n ? false\n : S extends ZodOptional\n ? false\n : S extends ZodObject\n ? true\n : S extends ZodRecord\n ? true\n : false,\n> {\n public readonly id: string\n private formattedName: string | null = null\n\n constructor(\n public readonly name: string | symbol | ClassType,\n public readonly schema: ZodObject | undefined,\n customId?: string,\n ) {\n this.id = generateTokenId(name, customId)\n }\n\n static create(\n name: T,\n ): InjectionToken, undefined>\n static create(\n name: T,\n schema: Schema,\n ): Schema['_def']['type'] extends 'ZodOptional'\n ? InjectionToken, Schema, false>\n : InjectionToken, Schema, true>\n static create(name: string | symbol): InjectionToken\n static create(\n name: string | any,\n schema: Schema,\n ): InjectionToken\n static create(name: string | symbol, schema?: unknown, customId?: string) {\n // @ts-expect-error\n return new InjectionToken(name, schema, customId)\n }\n\n static bound(\n token: InjectionToken,\n value: z.input,\n ): BoundInjectionToken {\n return new BoundInjectionToken(token, value)\n }\n\n static factory(\n token: InjectionToken,\n factory: (ctx: FactoryContext) => Promise>,\n ): FactoryInjectionToken {\n return new FactoryInjectionToken(token, factory)\n }\n\n static refineType(\n token: BoundInjectionToken,\n ): BoundInjectionToken {\n return token as BoundInjectionToken\n }\n\n toString() {\n if (this.formattedName) {\n return this.formattedName\n }\n const { name } = this\n if (typeof name === 'function') {\n const className = name.name\n this.formattedName = `${className}(${this.id})`\n } else if (typeof name === 'symbol') {\n this.formattedName = `${name.toString()}(${this.id})`\n } else {\n this.formattedName = `${name}(${this.id})`\n }\n\n return this.formattedName\n }\n}\n\nexport class BoundInjectionToken {\n public id: string\n public name: string | symbol | ClassType\n public schema: InjectionTokenSchemaType\n\n constructor(\n public readonly token: InjectionToken,\n public readonly value: z.input,\n ) {\n this.name = token.name\n this.id = token.id\n this.schema = token.schema as InjectionTokenSchemaType\n }\n\n toString() {\n return this.token.toString()\n }\n}\n\nexport class FactoryInjectionToken {\n public value?: z.input\n public resolved = false\n public id: string\n public name: string | symbol | ClassType\n public schema: InjectionTokenSchemaType\n\n constructor(\n public readonly token: InjectionToken,\n public readonly factory: (ctx: FactoryContext) => Promise>,\n ) {\n this.name = token.name\n this.id = token.id\n this.schema = token.schema as InjectionTokenSchemaType\n }\n\n async resolve(ctx: FactoryContext): Promise> {\n if (!this.value) {\n this.value = await this.factory(ctx)\n this.resolved = true\n }\n return this.value\n }\n\n toString() {\n return this.token.toString()\n }\n}\n\nexport type AnyInjectableType =\n | ClassType\n | InjectionToken\n | BoundInjectionToken\n | FactoryInjectionToken\n\nexport type InjectionTokenType =\n | InjectionToken\n | BoundInjectionToken\n | FactoryInjectionToken\n\n","import type { ClassType, InjectionToken } from './injection-token.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\n\nexport type FactoryRecord = {\n scope: InjectableScope\n originalToken: InjectionToken\n target: ClassType\n type: InjectableType\n priority: number\n}\n\nexport class Registry {\n private readonly factories = new Map()\n private readonly highestPriority = new Map()\n\n constructor(private readonly parent?: Registry) {}\n\n has(token: InjectionToken): boolean {\n if (this.factories.has(token.id)) {\n return true\n }\n if (this.parent) {\n return this.parent.has(token)\n }\n return false\n }\n\n get(\n token: InjectionToken,\n ): FactoryRecord {\n const factory = this.highestPriority.get(token.id)\n if (!factory) {\n if (this.parent) {\n return this.parent.get(token)\n }\n throw new Error(`[Registry] No factory found for ${token.toString()}`)\n }\n return factory\n }\n\n getAll(\n token: InjectionToken,\n ): FactoryRecord[] {\n const records = this.factories.get(token.id)\n if (!records || records.length === 0) {\n if (this.parent) {\n return this.parent.getAll(token)\n }\n return []\n }\n // Return sorted by priority (highest first)\n return [...records].sort((a, b) => b.priority - a.priority)\n }\n\n set(\n token: InjectionToken,\n scope: InjectableScope,\n target: ClassType,\n type: InjectableType,\n priority: number = 0,\n ) {\n const record: FactoryRecord = {\n scope,\n originalToken: token,\n target,\n type,\n priority,\n }\n\n // Add to factories array\n const existing = this.factories.get(token.id) || []\n existing.push(record)\n this.factories.set(token.id, existing)\n\n // Update highest priority cache if needed\n const currentHighest = this.highestPriority.get(token.id)\n if (!currentHighest || priority > currentHighest.priority) {\n this.highestPriority.set(token.id, record)\n }\n }\n\n delete(token: InjectionToken) {\n const records = this.factories.get(token.id)\n if (records) {\n const deletedHighest = this.highestPriority.get(token.id)\n this.factories.delete(token.id)\n this.highestPriority.delete(token.id)\n\n // If we deleted the highest priority record, recalculate from remaining records\n if (deletedHighest && records.length > 1) {\n const remaining = records.filter(\n (r) =>\n r.originalToken.id !== deletedHighest.originalToken.id ||\n r.priority !== deletedHighest.priority,\n )\n if (remaining.length > 0) {\n const newHighest = remaining.reduce((max, current) =>\n current.priority > max.priority ? current : max,\n )\n this.highestPriority.set(token.id, newHighest)\n this.factories.set(token.id, remaining)\n }\n }\n }\n }\n\n /**\n * Updates the scope of an already registered factory.\n * This is useful when you need to dynamically change a service's scope\n * (e.g., when a singleton controller has request-scoped dependencies).\n *\n * @param token The injection token to update\n * @param scope The new scope to set\n * @returns true if the scope was updated, false if the token was not found\n */\n updateScope(\n token: InjectionToken,\n scope: InjectableScope,\n ): boolean {\n const records = this.factories.get(token.id)\n if (records && records.length > 0) {\n // Update all records\n records.forEach((record) => {\n record.scope = scope\n })\n // Update highest priority cache if it exists\n const highest = this.highestPriority.get(token.id)\n if (highest) {\n highest.scope = scope\n }\n return true\n }\n if (this.parent) {\n return this.parent.updateScope(token, scope)\n }\n return false\n }\n}\n\nexport const globalRegistry = /* #__PURE__ */ new Registry()\n","import type { z } from 'zod/v4'\n\nimport type {\n BaseInjectionTokenSchemaType,\n ClassType,\n ClassTypeWithArgument,\n ClassTypeWithInstance,\n ClassTypeWithInstanceAndArgument,\n ClassTypeWithInstanceAndOptionalArgument,\n ClassTypeWithOptionalArgument,\n ClassTypeWithoutArguments,\n InjectionTokenSchemaType,\n OptionalInjectionTokenSchemaType,\n} from '../token/injection-token.mjs'\nimport type { Registry } from '../token/registry.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\nimport { InjectableTokenMeta } from '../symbols/index.mjs'\nimport { InjectionToken } from '../token/injection-token.mjs'\nimport { globalRegistry } from '../token/registry.mjs'\n\nexport interface InjectableOptions {\n scope?: InjectableScope\n token?: InjectionToken\n schema?: InjectionTokenSchemaType\n registry?: Registry\n priority?: number\n}\n\n// #1 Simple constructorless class\nexport function Injectable(): (\n target: T,\n context?: ClassDecoratorContext,\n) => T\nexport function Injectable(options: {\n scope?: InjectableScope\n registry: Registry\n priority?: number\n}): (\n target: T,\n context?: ClassDecoratorContext,\n) => T\nexport function Injectable(options: {\n scope: InjectableScope\n priority?: number\n}): (\n target: T,\n context?: ClassDecoratorContext,\n) => T\n// #2 Class with schema\nexport function Injectable(options: {\n scope?: InjectableScope\n schema: Schema\n registry?: Registry\n priority?: number\n}): >>(\n target: T,\n context?: ClassDecoratorContext,\n) => T\n\n// #3 Class with typeless token and schema\nexport function Injectable(options: {\n scope?: InjectableScope\n token: InjectionToken\n registry?: Registry\n priority?: number\n}): Schema extends BaseInjectionTokenSchemaType\n ? Type extends undefined\n ? >>(\n target: T,\n context?: ClassDecoratorContext,\n ) => T\n : >>(\n target: T,\n context?: ClassDecoratorContext,\n ) => T\n : Schema extends OptionalInjectionTokenSchemaType\n ? Type extends undefined\n ? >>(\n target: T,\n context?: ClassDecoratorContext,\n ) => T\n : <\n T extends ClassTypeWithInstanceAndOptionalArgument<\n Type,\n z.output\n >,\n >(\n target: T,\n context?: ClassDecoratorContext,\n ) => T\n : Schema extends undefined\n ? >(\n target: R,\n context?: ClassDecoratorContext,\n ) => R\n : never\n\nexport function Injectable({\n scope = InjectableScope.Singleton,\n token,\n schema,\n registry = globalRegistry,\n priority = 0,\n}: InjectableOptions = {}) {\n return (\n target: T,\n context?: ClassDecoratorContext,\n ): T => {\n if (\n (context && context.kind !== 'class') ||\n (target instanceof Function && !context)\n ) {\n throw new Error('[DI] @Injectable decorator can only be used on classes.')\n }\n if (schema && token) {\n throw new Error(\n '[DI] @Injectable decorator cannot have both a token and a schema',\n )\n }\n let injectableToken: InjectionToken =\n token ?? InjectionToken.create(target, schema as InjectionTokenSchemaType)\n\n registry.set(injectableToken, scope, target, InjectableType.Class, priority)\n\n // @ts-expect-error\n target[InjectableTokenMeta] = injectableToken\n\n return target\n }\n}\n","import { InjectionToken } from '@navios/di'\n\nimport type { BunControllerAdapterService } from '../services/controller-adapter.service.mjs'\n\n/**\n * Injection token for BunControllerAdapterService.\n *\n * This token allows overriding the default controller adapter with custom\n * implementations (e.g., for tracing or other middleware-like behavior).\n */\nexport const BunControllerAdapterToken =\n InjectionToken.create('BunControllerAdapterService')\n","import { InjectionToken } from '@navios/core'\n\n/**\n * Injection token for the current Bun request object.\n *\n * This token provides access to the current HTTP request within request-scoped\n * services. The request is automatically injected into the request-scoped container\n * for each incoming request.\n *\n * @example\n * ```ts\n * @Injectable()\n * class RequestService {\n * private request = inject(BunRequestToken)\n *\n * getUrl() {\n * return this.request.url\n * }\n *\n * getMethod() {\n * return this.request.method\n * }\n * }\n * ```\n */\nexport const BunRequestToken = InjectionToken.create('BunRequestToken')\n","import type { Server } from 'bun'\n\nimport { InjectionToken } from '@navios/core'\n\n/**\n * Injection token for the Bun server instance.\n *\n * This token provides access to the underlying Bun server instance,\n * allowing direct interaction with Bun's server API for advanced use cases\n * such as WebSocket upgrades or custom server configuration.\n *\n * @example\n * ```ts\n * @Injectable()\n * class WebSocketService {\n * private server = inject(BunServerToken)\n *\n * upgrade(request: Request) {\n * // Use server instance for WebSocket upgrades\n * return this.server.upgrade(request)\n * }\n * }\n * ```\n */\nexport const BunServerToken =\n InjectionToken.create>('BunServerToken')\n","import { InjectionToken } from '@navios/core'\n\nimport type { BunApplicationServiceInterface } from '../interfaces/application.interface.mjs'\n\n/**\n * Injection token for the Bun application service.\n *\n * This token is used to inject the `BunApplicationService` instance\n * into the dependency injection container. It provides access to the\n * HTTP adapter service for advanced use cases.\n *\n * @example\n * ```ts\n * @Injectable()\n * class MyService {\n * private appService = inject(BunApplicationServiceToken)\n *\n * getServer() {\n * return this.appService.getServer()\n * }\n * }\n * ```\n */\nexport const BunApplicationServiceToken =\n InjectionToken.create('BunApplicationService')\n","import type { AbstractHttpCorsOptions } from '@navios/core'\n\n/**\n * Function type for dynamic origin validation.\n * Called with the request origin and a callback to return the validation result.\n */\nexport type OriginFunction = (\n origin: string | undefined,\n callback: (error: Error | null, allow?: boolean | string) => void,\n) => void\n\n/**\n * Extended CORS options for the Bun adapter.\n * Extends the core AbstractHttpCorsOptions with support for function-based origin.\n */\nexport interface BunCorsOptions\n extends Omit {\n /**\n * Configures the Access-Control-Allow-Origin CORS header.\n * Can be a string, boolean, RegExp, array of these, or a function for dynamic validation.\n */\n origin?:\n | string\n | boolean\n | RegExp\n | (string | boolean | RegExp)[]\n | OriginFunction\n}\n\n/**\n * CORS headers that can be set on a response.\n */\nexport interface CorsHeaders {\n 'Access-Control-Allow-Origin'?: string\n 'Access-Control-Allow-Credentials'?: string\n 'Access-Control-Expose-Headers'?: string\n 'Access-Control-Allow-Headers'?: string\n 'Access-Control-Allow-Methods'?: string\n 'Access-Control-Max-Age'?: string\n 'Cache-Control'?: string\n Vary?: string\n}\n\n/**\n * Default allowed methods for CORS.\n */\nconst DEFAULT_METHODS = 'GET,HEAD,PUT,PATCH,POST,DELETE'\n\n/**\n * Checks if the origin is allowed based on the CORS configuration.\n * Returns the origin to reflect or false if not allowed.\n */\nasync function matchOrigin(\n requestOrigin: string | undefined,\n origin: BunCorsOptions['origin'],\n): Promise {\n // No origin header = same-origin request, allow but don't add CORS header\n if (!requestOrigin) {\n return false\n }\n\n // Boolean true = allow all origins (reflect the request origin)\n if (origin === true) {\n return requestOrigin\n }\n\n // Boolean false = no CORS\n if (origin === false) {\n return false\n }\n\n // String match\n if (typeof origin === 'string') {\n if (origin === '*') {\n return '*'\n }\n return origin === requestOrigin ? requestOrigin : false\n }\n\n // RegExp match\n if (origin instanceof RegExp) {\n return origin.test(requestOrigin) ? requestOrigin : false\n }\n\n // Array - check if any entry matches\n if (Array.isArray(origin)) {\n for (const entry of origin) {\n const result = await matchOrigin(requestOrigin, entry)\n if (result) {\n return result\n }\n }\n return false\n }\n\n // Function - promisify the callback style\n if (typeof origin === 'function') {\n return new Promise((resolve) => {\n origin(requestOrigin, (error, allow) => {\n if (error) {\n resolve(false)\n return\n }\n if (allow === true) {\n resolve(requestOrigin)\n } else if (typeof allow === 'string') {\n resolve(allow)\n } else {\n resolve(false)\n }\n })\n })\n }\n\n return false\n}\n\n/**\n * Normalizes a string or array of strings to a comma-separated string.\n */\nfunction normalizeToString(value: string | string[] | undefined): string {\n if (!value) return ''\n if (Array.isArray(value)) {\n return value.join(', ')\n }\n return value\n}\n\n/**\n * Calculates CORS headers for a request based on the provided options.\n *\n * @param requestOrigin - The Origin header from the request\n * @param options - CORS configuration options\n * @returns CORS headers object or null if origin is not allowed\n */\nexport async function calculateCorsHeaders(\n requestOrigin: string | undefined,\n options: BunCorsOptions,\n): Promise {\n const allowedOrigin = await matchOrigin(requestOrigin, options.origin)\n\n // If origin not allowed, return null (no CORS headers)\n if (!allowedOrigin) {\n return null\n }\n\n // Security: Cannot use wildcard origin with credentials\n // Per CORS spec, Access-Control-Allow-Origin cannot be '*' when credentials are included\n if (allowedOrigin === '*' && options.credentials) {\n throw new Error(\n 'CORS configuration error: Cannot use wildcard origin (*) with credentials: true. ' +\n 'Set a specific origin or use origin: true to reflect the request origin.',\n )\n }\n\n const headers: CorsHeaders = {\n 'Access-Control-Allow-Origin': allowedOrigin,\n }\n\n // Always set Vary: Origin when not using wildcard\n if (allowedOrigin !== '*') {\n headers.Vary = 'Origin'\n }\n\n // Credentials\n if (options.credentials) {\n headers['Access-Control-Allow-Credentials'] = 'true'\n }\n\n // Exposed headers (for actual requests)\n if (options.exposedHeaders) {\n headers['Access-Control-Expose-Headers'] = normalizeToString(\n options.exposedHeaders,\n )\n }\n\n return headers\n}\n\n/**\n * Calculates CORS headers specifically for preflight (OPTIONS) requests.\n *\n * @param requestOrigin - The Origin header from the request\n * @param requestMethod - The Access-Control-Request-Method header\n * @param requestHeaders - The Access-Control-Request-Headers header\n * @param options - CORS configuration options\n * @returns CORS headers object or null if origin is not allowed\n */\nexport async function calculatePreflightHeaders(\n requestOrigin: string | undefined,\n requestMethod: string | null,\n requestHeaders: string | null,\n options: BunCorsOptions,\n): Promise {\n const baseHeaders = await calculateCorsHeaders(requestOrigin, options)\n\n if (!baseHeaders) {\n return null\n }\n\n // Add preflight-specific headers\n const headers: CorsHeaders = { ...baseHeaders }\n\n // Allowed methods\n headers['Access-Control-Allow-Methods'] = options.methods\n ? normalizeToString(options.methods)\n : DEFAULT_METHODS\n\n // Allowed headers - reflect request headers if not specified\n if (options.allowedHeaders) {\n headers['Access-Control-Allow-Headers'] = normalizeToString(\n options.allowedHeaders,\n )\n } else if (requestHeaders) {\n // Reflect the requested headers\n headers['Access-Control-Allow-Headers'] = requestHeaders\n // Add Vary for Access-Control-Request-Headers since we're reflecting\n headers.Vary = headers.Vary\n ? `${headers.Vary}, Access-Control-Request-Headers`\n : 'Access-Control-Request-Headers'\n }\n\n // Max age\n if (options.maxAge !== undefined) {\n headers['Access-Control-Max-Age'] = String(options.maxAge)\n }\n\n // Cache control for preflight\n if (options.cacheControl !== undefined) {\n if (typeof options.cacheControl === 'number') {\n headers['Cache-Control'] = `max-age=${options.cacheControl}`\n } else {\n headers['Cache-Control'] = options.cacheControl\n }\n }\n\n return headers\n}\n\n/**\n * Checks if a request is a CORS preflight request.\n *\n * @param method - The HTTP method of the request\n * @param origin - The Origin header value\n * @param accessControlRequestMethod - The Access-Control-Request-Method header\n * @returns true if this is a preflight request\n */\nexport function isPreflight(\n method: string,\n origin: string | null,\n accessControlRequestMethod: string | null,\n): boolean {\n return (\n method === 'OPTIONS' && !!origin && accessControlRequestMethod !== null\n )\n}\n\n/**\n * Applies CORS headers to a Response object.\n *\n * @param response - The original response\n * @param requestOrigin - The Origin header from the request\n * @param options - CORS configuration options\n * @returns A new Response with CORS headers, or the original if origin not allowed\n */\nexport async function applyCorsToResponse(\n response: Response,\n requestOrigin: string | null,\n options: BunCorsOptions | null,\n): Promise {\n if (!options) {\n return response\n }\n\n const corsHeaders = await calculateCorsHeaders(\n requestOrigin ?? undefined,\n options,\n )\n\n if (!corsHeaders) {\n return response\n }\n\n const headers = new Headers(response.headers)\n for (const [key, value] of Object.entries(corsHeaders)) {\n if (value) {\n headers.set(key, value)\n }\n }\n\n return new Response(response.body, {\n status: response.status,\n statusText: response.statusText,\n headers,\n })\n}\n","import type {\n CanActivate,\n ClassType,\n ControllerMetadata,\n HandlerMetadata,\n ModuleMetadata,\n} from '@navios/core'\nimport type { BunRequest } from 'bun'\n\nimport {\n Container,\n ErrorResponseProducerService,\n ExecutionContext,\n extractControllerMetadata,\n FrameworkError,\n generateRequestId,\n GuardRunnerService,\n HttpException,\n inject,\n Injectable,\n InjectionToken,\n InstanceResolverService,\n Logger,\n runWithRequestId,\n} from '@navios/core'\n\nimport { ZodError } from 'zod/v4'\n\nimport type {\n BunHandlerAdapterInterface,\n BunHandlerResult,\n} from '../adapters/index.mjs'\n\nimport { BunExecutionContext, BunFakeReply } from '../interfaces/index.mjs'\nimport {\n BunControllerAdapterToken,\n BunRequestToken,\n} from '../tokens/index.mjs'\nimport {\n applyCorsToResponse,\n type BunCorsOptions,\n} from '../utils/cors.util.mjs'\n\n/**\n * Type definition for Bun route mappings.\n *\n * Maps route paths to HTTP method handlers. Each route path can have\n * multiple HTTP methods (GET, POST, PUT, DELETE, etc.) associated with it.\n */\nexport type BunRoutes = Record<\n string,\n { [method: string]: (req: BunRequest) => Response | Promise }\n>\n\n/**\n * Service responsible for adapting Navios controllers to Bun route handlers.\n *\n * This service processes controller metadata, sets up route handlers,\n * integrates with guards, and handles request/response lifecycle. It\n * bridges the gap between Navios's controller decorators and Bun's\n * native routing system.\n *\n * @example\n * ```ts\n * // This service is used automatically by the Bun adapter\n * // Controllers are automatically registered when modules are initialized\n * @Module({\n * controllers: [UserController],\n * })\n * class AppModule {}\n * ```\n */\n@Injectable({ token: BunControllerAdapterToken })\nexport class BunControllerAdapterService {\n private guardRunner = inject(GuardRunnerService)\n private container = inject(Container)\n private instanceResolver = inject(InstanceResolverService)\n private errorProducer = inject(ErrorResponseProducerService)\n private logger = inject(Logger, {\n context: BunControllerAdapterService.name,\n })\n\n /**\n * Sets up route handlers for a controller.\n *\n * This method processes all endpoints defined in a controller, creates\n * appropriate route handlers using the configured adapter services,\n * and registers them with Bun's routing system.\n *\n * @param controller - The controller class to set up.\n * @param routes - The routes object to populate with handlers.\n * @param moduleMetadata - Metadata about the module containing the controller.\n * @param globalPrefix - The global prefix to prepend to all routes.\n * @param corsOptions - Optional CORS configuration to apply to responses.\n *\n * @throws {Error} If an endpoint is malformed (missing URL or adapter token).\n */\n async setupController(\n controller: ClassType,\n routes: BunRoutes,\n moduleMetadata: ModuleMetadata,\n globalPrefix: string,\n corsOptions: BunCorsOptions | null = null,\n ) {\n const controllerMetadata = extractControllerMetadata(controller)\n for (const endpoint of controllerMetadata.endpoints) {\n const { classMethod, url, httpMethod, adapterToken } = endpoint\n\n if (!url || !adapterToken) {\n throw new Error(\n `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`,\n )\n }\n const adapter = await this.container.get(\n adapterToken as InjectionToken,\n )\n\n // Pre-resolve guards (reversed order: module → controller → endpoint)\n const guards = this.guardRunner.makeContext(\n moduleMetadata,\n controllerMetadata,\n endpoint,\n )\n const guardResolution =\n await this.instanceResolver.resolveMany(\n Array.from(guards).reverse() as ClassType[],\n )\n\n const fullUrl = globalPrefix + url.replaceAll('$', ':')\n if (!routes[fullUrl]) {\n routes[fullUrl] = {}\n }\n routes[fullUrl][httpMethod] = this.wrapHandler(\n await adapter.provideHandler(controller, endpoint),\n guardResolution,\n moduleMetadata,\n controllerMetadata,\n endpoint,\n corsOptions,\n )\n\n this.logger.debug(\n `Registered ${httpMethod} ${fullUrl} for ${controller.name}:${classMethod}`,\n )\n }\n }\n\n /**\n * Wraps a route handler with request context, guards, error handling, and CORS.\n *\n * This method creates a complete request handler using one of three paths:\n * 1. Static handler + no guards: Direct handler call (fastest)\n * 2. Static handler + static guards: Call pre-resolved guards, then handler\n * 3. Dynamic: Full flow with scoped container\n *\n * @param handlerResult - The handler result from the adapter service.\n * @param guardResolution - Pre-resolved guards or resolver function.\n * @param moduleMetadata - Metadata about the module.\n * @param controllerMetadata - Metadata about the controller.\n * @param endpoint - Metadata about the endpoint handler.\n * @param corsOptions - Optional CORS configuration to apply to responses.\n * @returns A wrapped handler function that can be registered with Bun.\n * @private\n */\n private wrapHandler(\n handlerResult: BunHandlerResult,\n guardResolution: {\n cached: boolean\n instances: CanActivate[] | null\n classTypes: ClassType[]\n },\n moduleMetadata: ModuleMetadata,\n controllerMetadata: ControllerMetadata,\n endpoint: HandlerMetadata,\n corsOptions: BunCorsOptions | null,\n ) {\n const hasGuards = guardResolution.classTypes.length > 0\n\n // Path 1: Static handler, no guards (fastest)\n if (handlerResult.isStatic && !hasGuards) {\n return async (request: BunRequest) => {\n const origin = request.headers.get('Origin')\n try {\n return await runWithRequestId(generateRequestId(), async () => {\n const response = await handlerResult.handler(request)\n return applyCorsToResponse(response, origin, corsOptions)\n })\n } catch (error) {\n const errorResponse = this.handleError(error)\n return applyCorsToResponse(errorResponse, origin, corsOptions)\n }\n }\n }\n\n // Path 2: Static handler + static guards\n if (handlerResult.isStatic && guardResolution.cached) {\n return async (request: BunRequest) => {\n const origin = request.headers.get('Origin')\n const fakeReply = new BunFakeReply()\n const executionContext = new BunExecutionContext(\n moduleMetadata,\n controllerMetadata,\n endpoint,\n request,\n fakeReply,\n )\n try {\n return await runWithRequestId(generateRequestId(), async () => {\n const canActivate = await this.guardRunner.runGuardsStatic(\n guardResolution.instances!,\n executionContext,\n )\n if (!canActivate) {\n // Check if guard set a custom response via the fake reply\n if (fakeReply.hasResponse()) {\n return applyCorsToResponse(\n fakeReply.toResponse(),\n origin,\n corsOptions,\n )\n }\n return applyCorsToResponse(\n new Response('Forbidden', { status: 403 }),\n origin,\n corsOptions,\n )\n }\n const response = await handlerResult.handler(request)\n return applyCorsToResponse(response, origin, corsOptions)\n })\n } catch (error) {\n const errorResponse = this.handleError(error)\n return applyCorsToResponse(errorResponse, origin, corsOptions)\n }\n }\n }\n\n // Path 3: Dynamic (default) - need scoped container\n // Get guard tokens for dynamic resolution\n const guards = new Set(guardResolution.classTypes)\n\n return async (request: BunRequest) => {\n const origin = request.headers.get('Origin')\n const fakeReply = new BunFakeReply()\n const executionContext = new BunExecutionContext(\n moduleMetadata,\n controllerMetadata,\n endpoint,\n request,\n fakeReply,\n )\n const requestId = generateRequestId()\n const requestContainer = this.container.beginRequest(requestId)\n requestContainer.addInstance(BunRequestToken, request)\n requestContainer.addInstance(ExecutionContext, executionContext)\n\n try {\n return await runWithRequestId(requestId, async () => {\n // Run guards if there are any\n if (hasGuards) {\n const canActivate = await this.guardRunner.runGuards(\n guards as any,\n executionContext,\n requestContainer,\n )\n if (!canActivate) {\n // Check if guard set a custom response via the fake reply\n if (fakeReply.hasResponse()) {\n return applyCorsToResponse(\n fakeReply.toResponse(),\n origin,\n corsOptions,\n )\n }\n return applyCorsToResponse(\n new Response('Forbidden', { status: 403 }),\n origin,\n corsOptions,\n )\n }\n }\n\n // Handler is dynamic, needs scoped container\n if (!handlerResult.isStatic) {\n const response = await handlerResult.handler(requestContainer, request)\n return applyCorsToResponse(response, origin, corsOptions)\n }\n // Handler is static but guards are dynamic\n const response = await handlerResult.handler(request)\n return applyCorsToResponse(response, origin, corsOptions)\n })\n } catch (error) {\n const errorResponse = this.handleError(error)\n return applyCorsToResponse(errorResponse, origin, corsOptions)\n } finally {\n requestContainer.endRequest().catch((err: any) => {\n this.logger.error(\n `Error ending request context ${requestId}: ${err.message}`,\n err,\n )\n })\n }\n }\n }\n\n /**\n * Handles errors and converts them to appropriate HTTP responses.\n * Uses ErrorResponseProducerService to produce RFC 7807 compliant responses.\n * @private\n */\n private handleError(error: unknown): Response {\n let errorResponse\n\n if (error instanceof HttpException) {\n // For HttpException, preserve original response format for backwards compatibility\n return new Response(JSON.stringify(error.response), {\n status: error.statusCode,\n headers: { 'Content-Type': 'application/json' },\n })\n } else if (error instanceof ZodError) {\n errorResponse = this.errorProducer.respond(\n FrameworkError.ValidationError,\n error,\n )\n } else {\n // Log unexpected errors\n const err = error as Error\n this.logger.error(`Error: ${err.message}`, err)\n errorResponse = this.errorProducer.handleUnknown(error)\n }\n\n return new Response(JSON.stringify(errorResponse.payload), {\n status: errorResponse.statusCode,\n headers: errorResponse.headers,\n })\n }\n}\n","import type { ModuleMetadata } from '@navios/core'\nimport type { BunRequest, Serve, Server } from 'bun'\n\nimport {\n Container,\n ErrorResponseProducerService,\n FrameworkError,\n inject,\n Injectable,\n Logger,\n} from '@navios/core'\n\nimport type {\n BunApplicationOptions,\n BunApplicationServiceInterface,\n} from '../interfaces/application.interface.mjs'\nimport type { BunCorsOptions } from '../utils/cors.util.mjs'\nimport type { BunRoutes } from './controller-adapter.service.mjs'\n\nimport {\n BunApplicationServiceToken,\n BunControllerAdapterToken,\n BunServerToken,\n} from '../tokens/index.mjs'\nimport {\n applyCorsToResponse,\n calculatePreflightHeaders,\n isPreflight,\n} from '../utils/cors.util.mjs'\n\n/**\n * Bun HTTP adapter service implementation for Navios.\n *\n * This service provides the core HTTP server functionality for Navios applications\n * running on the Bun runtime. It handles server initialization, route registration,\n * request handling, and server lifecycle management.\n *\n * @example\n * ```ts\n * const app = await NaviosFactory.create(AppModule, {\n * adapter: defineBunEnvironment(),\n * })\n *\n * app.configure({ development: true })\n * await app.init()\n * await app.listen({ port: 3000, hostname: '0.0.0.0' })\n * ```\n *\n * @implements {BunApplicationServiceInterface}\n */\n@Injectable({\n token: BunApplicationServiceToken,\n})\nexport class BunApplicationService implements BunApplicationServiceInterface {\n private logger = inject(Logger, {\n context: BunApplicationService.name,\n })\n protected container = inject(Container)\n private errorProducer = inject(ErrorResponseProducerService)\n private server: Server | null = null\n private controllerAdapter = inject(BunControllerAdapterToken)\n private globalPrefix: string = ''\n private routes: BunRoutes = {}\n private serverOptions: BunApplicationOptions | null = null\n private corsOptions: BunCorsOptions | null = null\n private configureOptions: Partial = {}\n\n /**\n * app.configure({\n * development: process.env.NODE_ENV === 'development',\n * maxRequestBodySize: 1024 * 1024, // 1MB\n * })\n * await app.init()\n * ```\n */\n async setupAdapter(options: unknown): Promise {\n // Merge configure options with passed options (configure takes precedence)\n const mergedOptions = {\n ...(options as BunApplicationOptions),\n ...this.configureOptions,\n } as BunApplicationOptions\n // Collect routes from modules\n // But modules are set in onModulesInit, so assume it's called before\n this.serverOptions = mergedOptions\n }\n\n /**\n * Initializes the Bun server instance and registers it in the dependency injection container.\n *\n * This method is called automatically during the application initialization process.\n * It makes the server instance available for injection via `BunServerToken`.\n *\n * @throws {Error} If the server has not been created yet.\n */\n async initServer(): Promise {\n // Register server instance\n this.container.addInstance(BunServerToken, this.server!)\n }\n\n /**\n * Marks the server as ready.\n *\n * For Bun, the server is ready immediately upon creation, so this is a no-op.\n */\n async ready(): Promise {\n // Bun server is ready when created\n }\n\n /**\n * Sets a global prefix for all routes.\n *\n * This prefix will be prepended to all registered route paths. Useful for\n * API versioning or organizing routes under a common path.\n *\n * @param prefix - The prefix to prepend to all routes (e.g., '/api/v1').\n * Should start with a forward slash.\n *\n * @example\n * ```ts\n * app.setGlobalPrefix('/api/v1')\n * // All routes will be prefixed with /api/v1\n * ```\n */\n setGlobalPrefix(prefix: string): void {\n this.globalPrefix = prefix\n }\n\n /**\n * Gets the current global prefix for all routes.\n *\n * @returns The global prefix string, or empty string if no prefix is set.\n *\n * @example\n * ```ts\n * app.setGlobalPrefix('/api/v1')\n * console.log(app.getGlobalPrefix()) // '/api/v1'\n * ```\n */\n getGlobalPrefix(): string {\n return this.globalPrefix\n }\n\n /**\n * Gets the underlying Bun server instance.\n *\n * This allows direct access to the Bun server for advanced use cases,\n * such as WebSocket upgrades or custom middleware.\n *\n * @returns The Bun server instance.\n * @throws {Error} If the server has not been initialized yet.\n *\n * @example\n * ```ts\n * const server = app.getServer()\n * // Access Bun-specific server methods\n * ```\n */\n getServer(): Server {\n if (!this.server) {\n throw new Error('Server is not initialized. Call createHttpServer first.')\n }\n return this.server\n }\n\n async onModulesInit(modules: Map): Promise {\n for (const [_moduleName, moduleMetadata] of modules) {\n if (\n !moduleMetadata.controllers ||\n moduleMetadata.controllers.size === 0\n ) {\n continue\n }\n for (const controller of moduleMetadata.controllers) {\n await this.controllerAdapter.setupController(\n controller,\n this.routes,\n moduleMetadata,\n this.globalPrefix,\n this.corsOptions,\n )\n }\n }\n }\n\n /**\n * Fallback request handler for unmatched routes and CORS preflight.\n *\n * Handles:\n * - CORS preflight (OPTIONS) requests\n * - 404 responses for unmatched routes with CORS headers\n *\n * @param request - The incoming request\n * @returns A Response with appropriate status and CORS headers\n * @private\n */\n private async handleRequest(request: BunRequest): Promise {\n const origin = request.headers.get('Origin')\n const accessControlRequestMethod = request.headers.get(\n 'Access-Control-Request-Method',\n )\n\n // Handle CORS preflight requests\n if (\n this.corsOptions &&\n isPreflight(request.method, origin, accessControlRequestMethod)\n ) {\n const requestHeaders = request.headers.get(\n 'Access-Control-Request-Headers',\n )\n const preflightHeaders = await calculatePreflightHeaders(\n origin ?? undefined,\n accessControlRequestMethod,\n requestHeaders,\n this.corsOptions,\n )\n\n if (preflightHeaders) {\n return new Response(null, {\n status: 204,\n headers: preflightHeaders as HeadersInit,\n })\n }\n }\n\n // Build 404 response using ErrorResponseProducerService\n const errorResponse = this.errorProducer.respond(\n FrameworkError.NotFound,\n null,\n `Route [${request.method}] ${request.url} not found`,\n )\n\n const response = new Response(JSON.stringify(errorResponse.payload), {\n status: errorResponse.statusCode,\n headers: errorResponse.headers,\n })\n\n // Apply CORS headers to the error response\n return applyCorsToResponse(response, origin, this.corsOptions)\n }\n\n /**\n * Enables CORS (Cross-Origin Resource Sharing) support.\n *\n * Configures CORS headers for all routes. The options are applied when\n * handling requests.\n *\n * @param options - CORS configuration options.\n *\n * @example\n * ```ts\n * app.enableCors({\n * origin: true, // Allow all origins\n * methods: ['GET', 'POST', 'PUT', 'DELETE'],\n * credentials: true,\n * })\n * ```\n */\n enableCors(options: BunCorsOptions): void {\n this.corsOptions = options\n }\n\n /**\n * Enables multipart form data support.\n *\n * @param _options - Multipart options (not currently supported in Bun adapter).\n * @deprecated Multipart support is handled automatically by Bun's native FormData support.\n */\n enableMultipart(): void {\n // Ignore for now\n }\n\n /**\n * Starts the Bun HTTP server and begins listening for incoming requests.\n *\n * This method creates and starts the Bun server with the configured routes\n * and options. The server will handle all registered routes and return 404\n * for unmatched requests.\n *\n * @param options - Server listen options including port and hostname.\n * @returns A promise that resolves to a string in the format `hostname:port`\n * indicating where the server is listening.\n *\n * @example\n * ```ts\n * const address = await app.listen({\n * port: 3000,\n * hostname: '0.0.0.0',\n * })\n * console.log(`Server listening on ${address}`)\n * ```\n */\n async listen(options: any): Promise {\n // Server is already listening\n const port = options.port || 3000\n const hostname = options.hostname || 'localhost'\n\n this.server = Bun.serve({\n ...(this.serverOptions as Serve.Options),\n routes: this.routes,\n port,\n hostname,\n fetch: this.handleRequest.bind(this),\n })\n this.initServer()\n this.logger.log(\n `Bun server listening on http://${hostname}:${port}`,\n 'Bootstrap',\n )\n return `${hostname}:${port}`\n }\n\n /**\n * Configures the adapter with additional options before initialization.\n *\n * Options set via configure() are merged with options passed to\n * setupAdapter(), with configure() options taking precedence.\n * Must be called before init().\n *\n * @param options - Partial Bun server configuration options\n *\n * @example\n * ```ts\n * app.configure({ development: true })\n * await app.init()\n * ```\n */\n configure(options: Partial): void {\n this.configureOptions = {\n ...this.configureOptions,\n ...(options as Record),\n }\n }\n\n /**\n * Gracefully shuts down the Bun server.\n *\n * This method stops the server and cleans up resources. Should be called\n * during application shutdown to ensure proper cleanup.\n *\n * @example\n * ```ts\n * process.on('SIGTERM', async () => {\n * await app.dispose()\n * process.exit(0)\n * })\n * ```\n */\n async dispose(): Promise {\n this.server?.stop()\n }\n}\n","import type { AnyInjectableType } from '@navios/core'\n\nimport {\n AdapterToken,\n EndpointAdapterToken,\n HttpAdapterToken,\n InjectionToken,\n MultipartAdapterToken,\n Request,\n StreamAdapterToken,\n} from '@navios/core'\n\nimport {\n BunEndpointAdapterService,\n BunMultipartAdapterService,\n BunStreamAdapterService,\n} from './adapters/index.mjs'\nimport { BunApplicationService } from './services/index.mjs'\nimport { BunRequestToken } from './tokens/index.mjs'\n\n/**\n * Creates a Bun adapter environment configuration for Navios.\n *\n * This function sets up the necessary dependency injection tokens and services\n * required to run Navios applications on the Bun runtime. It configures:\n * - HTTP adapter service for handling HTTP requests\n * - Endpoint adapter for standard REST endpoints\n * - Stream adapter for streaming responses\n * - Multipart adapter for file uploads and form data\n * - Request token for accessing the current Bun request\n *\n * @returns An object containing the token mappings for the Bun adapter.\n * This object should be passed to `NaviosFactory.create()` as the `adapter` option.\n *\n * @example\n * ```ts\n * import { defineBunEnvironment } from '@navios/adapter-bun'\n * import { NaviosFactory } from '@navios/core'\n *\n * const app = await NaviosFactory.create(AppModule, {\n * adapter: defineBunEnvironment(),\n * })\n * ```\n *\n * @example\n * ```ts\n * // With custom Bun server options\n * const app = await NaviosFactory.create(AppModule, {\n * adapter: defineBunEnvironment(),\n * })\n *\n * app.configure({\n * development: process.env.NODE_ENV === 'development',\n * })\n * await app.init()\n * ```\n *\n * @see {@link BunApplicationService} The HTTP adapter service implementation\n * @see {@link BunEndpointAdapterService} The endpoint adapter implementation\n * @see {@link BunStreamAdapterService} The stream adapter implementation\n * @see {@link BunMultipartAdapterService} The multipart adapter implementation\n */\nexport function defineBunEnvironment() {\n const tokens = new Map, AnyInjectableType>([\n [AdapterToken, BunApplicationService],\n [HttpAdapterToken, BunApplicationService],\n [EndpointAdapterToken, BunEndpointAdapterService],\n [StreamAdapterToken, BunStreamAdapterService],\n [MultipartAdapterToken, BunMultipartAdapterService],\n [Request, BunRequestToken],\n ])\n return {\n tokens,\n }\n}\n"],"x_google_ignoreList":[6,7,8,9],"mappings":"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"}