silgi 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/adapters/_fetch-adapter.d.mts

@@ -0,0 +1,18 @@
+//#region src/adapters/_fetch-adapter.d.ts
+interface FetchAdapterConfig<TCtx extends Record<string, unknown>> {
+  /** Route prefix to strip. Default: "/api/rpc" */
+  prefix?: string;
+  /** Context factory — receives the Request (or framework event via eventMap). */
+  context?: (req: Request) => TCtx | Promise<TCtx>;
+}
+/**
+ * For adapters where the context factory needs access to a framework event
+ * (SvelteKit RequestEvent, SolidStart event), use this extended config.
+ */
+interface FetchAdapterConfigWithEvent<TCtx extends Record<string, unknown>, TEvent = any> {
+  prefix?: string;
+  /** Context factory — receives the framework event, not raw Request. */
+  context?: (event: TEvent) => TCtx | Promise<TCtx>;
+}
+//#endregion
+export { FetchAdapterConfig, FetchAdapterConfigWithEvent };

package/dist/adapters/_fetch-adapter.mjs

@@ -0,0 +1,53 @@
+import { createFetchHandler } from "../core/handler.mjs";
+//#region src/adapters/_fetch-adapter.ts
+/**
+* Shared factory for fetch-passthrough adapters.
+*
+* Next.js, Astro, Remix, SvelteKit, and SolidStart all do the same thing:
+* strip URL prefix → rewrite request → dispatch to fetch handler.
+*
+* This module eliminates the duplication. Each adapter file becomes a thin
+* wrapper that extracts the framework-specific Request and calls this factory.
+*/
+/** Strip prefix from request URL and create a rewritten Request. */
+function rewriteRequest(request, prefix) {
+	const url = new URL(request.url);
+	let pathname = url.pathname;
+	if (pathname.startsWith(prefix)) {
+		pathname = pathname.slice(prefix.length);
+		if (!pathname.startsWith("/")) pathname = "/" + pathname;
+	}
+	return new Request(new URL(pathname + url.search, url.origin), request);
+}
+/**
+* Create a fetch-passthrough adapter that strips a prefix and delegates to handler.
+* Used by adapters that receive a standard Request (Next.js, Astro, Remix).
+*/
+function createFetchAdapter(router, options, defaultPrefix) {
+	const prefix = options.prefix ?? defaultPrefix;
+	const handler = createFetchHandler(router, options.context ?? (() => ({})));
+	return (request) => {
+		return handler(rewriteRequest(request, prefix));
+	};
+}
+/**
+* Create a fetch-passthrough adapter for frameworks that pass an event object
+* with a `.request` property (SvelteKit, SolidStart).
+* Uses a WeakMap to safely pass the event into the context factory per-request.
+*/
+function createEventFetchAdapter(router, options, defaultPrefix, extractRequest) {
+	const prefix = options.prefix ?? defaultPrefix;
+	const requestEventMap = /* @__PURE__ */ new WeakMap();
+	const handler = createFetchHandler(router, (_req) => {
+		const eventRef = requestEventMap.get(_req);
+		if (options.context && eventRef) return options.context(eventRef);
+		return {};
+	});
+	return (event) => {
+		const rewritten = rewriteRequest(extractRequest(event), prefix);
+		requestEventMap.set(rewritten, event);
+		return handler(rewritten);
+	};
+}
+//#endregion
+export { createEventFetchAdapter, createFetchAdapter };

package/dist/adapters/astro.d.mts

@@ -1,17 +1,15 @@
 import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfig } from "./_fetch-adapter.mjs";
 
 //#region src/adapters/astro.d.ts
-interface AstroAdapterOptions<TCtx extends Record<string, unknown>> {
-  context?: (request: Request) => TCtx | Promise<TCtx>;
-  prefix?: string;
-}
+interface AstroAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfig<TCtx> {}
 /**
  * Create an Astro API route handler.
- * Astro passes { request: Request, params } — uses Silgi's handler().
+ * Astro passes { request, params } — we extract request and delegate.
  */
-declare function silgiAstro<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
   request: Request;
   params: Record<string, string>;
-}) => Promise<Response>;
+}) => Response | Promise<Response>;
 //#endregion
-export { AstroAdapterOptions, silgiAstro };
+export { AstroAdapterOptions, createHandler };

package/dist/adapters/astro.mjs

@@ -1,24 +1,31 @@
+import { createFetchAdapter } from "./_fetch-adapter.mjs";
 //#region src/adapters/astro.ts
 /**
+* Astro adapter — use Silgi with Astro API routes.
+*
+* @example
+* ```ts
+* // src/pages/api/rpc/[...path].ts
+* import { createHandler } from "silgi/astro"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   prefix: "/api/rpc",
+*   context: (req) => ({ db: getDB() }),
+* })
+*
+* export const GET = handler
+* export const POST = handler
+* export const ALL = handler
+* ```
+*/
+/**
 * Create an Astro API route handler.
-* Astro passes { request: Request, params } — uses Silgi's handler().
+* Astro passes { request, params } — we extract request and delegate.
 */
-function silgiAstro(router, options = {}) {
-	const prefix = options.prefix ?? "/api/rpc";
-	let _handler = null;
-	return async ({ request }) => {
-		if (!_handler) {
-			const { silgi } = await import("../silgi.mjs");
-			_handler = silgi({ context: options.context ?? (() => ({})) }).handler(router);
-		}
-		const url = new URL(request.url);
-		let pathname = url.pathname;
-		if (pathname.startsWith(prefix)) {
-			pathname = pathname.slice(prefix.length);
-			if (!pathname.startsWith("/")) pathname = "/" + pathname;
-		}
-		return _handler(new Request(new URL(pathname + url.search, url.origin), request));
-	};
+function createHandler(router, options = {}) {
+	const handler = createFetchAdapter(router, options, "/api/rpc");
+	return ({ request }) => handler(request);
 }
 //#endregion
-export { silgiAstro };
+export { createHandler };

package/dist/adapters/aws-lambda.d.mts

@@ -8,14 +8,25 @@ interface LambdaAdapterOptions<TCtx extends Record<string, unknown>> {
   prefix?: string;
 }
 interface LambdaEvent {
-  httpMethod: string;
-  path: string;
+  httpMethod?: string;
+  path?: string;
+  version?: string;
+  rawPath?: string;
+  requestContext?: {
+    http?: {
+      method: string;
+      path: string;
+    };
+    [key: string]: unknown;
+  };
   body: string | null;
   headers: Record<string, string>;
   queryStringParameters: Record<string, string> | null;
-  requestContext?: Record<string, unknown>;
   isBase64Encoded?: boolean;
 }
+interface LambdaContext {
+  getRemainingTimeInMillis?: () => number;
+}
 interface LambdaResponse {
   statusCode: number;
   headers: Record<string, string>;
@@ -26,6 +37,6 @@ interface LambdaResponse {
  *
  * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
  */
-declare function silgiLambda<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent) => Promise<LambdaResponse>;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResponse>;
 //#endregion
-export { LambdaAdapterOptions, silgiLambda };
+export { LambdaAdapterOptions, createHandler };

package/dist/adapters/aws-lambda.mjs

@@ -1,15 +1,14 @@
-import { SilgiError, toSilgiError } from "../core/error.mjs";
-import { ValidationError } from "../core/schema.mjs";
 import { compileRouter } from "../compile.mjs";
+import { buildContext, isMethodAllowed, parseQueryData, serializeError } from "../core/dispatch.mjs";
 //#region src/adapters/aws-lambda.ts
 /**
 * AWS Lambda adapter — deploy Silgi as a Lambda function.
 *
 * @example
 * ```ts
-* import { silgiLambda } from "silgi/aws-lambda"
+* import { createHandler } from "silgi/aws-lambda"
 *
-* export const handler = silgiLambda(appRouter, {
+* export const handler = createHandler(appRouter, {
 *   context: (event) => ({ db: getDB(), userId: event.requestContext?.authorizer?.userId }),
 * })
 * ```
@@ -19,17 +18,20 @@ import { compileRouter } from "../compile.mjs";
 *
 * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
 */
-function silgiLambda(router, options = {}) {
+function createHandler(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	const prefix = options.prefix ?? "";
-	return async (event) => {
-		let pathname = event.path;
+	const JSON_HDR = { "content-type": "application/json" };
+	return async (event, context) => {
+		const isV2 = event.version === "2.0";
+		const method = isV2 ? event.requestContext?.http?.method ?? "GET" : event.httpMethod ?? "GET";
+		let pathname = isV2 ? event.rawPath ?? "/" : event.path ?? "/";
 		if (prefix && pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
 		if (pathname.startsWith("/")) pathname = pathname.slice(1);
-		const match = flatRouter(event.httpMethod, "/" + pathname);
+		const match = flatRouter(method, "/" + pathname);
 		if (!match) return {
 			statusCode: 404,
-			headers: { "content-type": "application/json" },
+			headers: JSON_HDR,
 			body: JSON.stringify({
 				code: "NOT_FOUND",
 				status: 404,
@@ -37,49 +39,54 @@ function silgiLambda(router, options = {}) {
 			})
 		};
 		const route = match.data;
+		if (!isMethodAllowed(method, route.method)) return {
+			statusCode: 405,
+			headers: {
+				...JSON_HDR,
+				allow: route.method
+			},
+			body: JSON.stringify({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${method} not allowed`
+			})
+		};
 		try {
-			const ctx = Object.create(null);
-			if (match.params) ctx.params = match.params;
-			if (options.context) {
-				const baseCtx = await options.context(event);
-				const keys = Object.keys(baseCtx);
-				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
-			}
+			const ctx = buildContext(options.context ? await options.context(event) : void 0, match.params);
 			let input;
 			if (event.body) {
 				const body = event.isBase64Encoded ? Buffer.from(event.body, "base64").toString("utf-8") : event.body;
 				try {
 					input = JSON.parse(body);
-				} catch {}
-			} else if (event.queryStringParameters?.data) try {
-				input = JSON.parse(event.queryStringParameters.data);
-			} catch {}
-			const signal = AbortSignal.timeout(3e4);
+				} catch {
+					return {
+						statusCode: 400,
+						headers: JSON_HDR,
+						body: JSON.stringify({
+							code: "BAD_REQUEST",
+							status: 400,
+							message: "Invalid JSON body"
+						})
+					};
+				}
+			} else if (event.queryStringParameters?.data) input = parseQueryData(event.queryStringParameters.data);
+			const timeoutMs = context?.getRemainingTimeInMillis ? context.getRemainingTimeInMillis() - 500 : 3e4;
+			const signal = AbortSignal.timeout(Math.max(timeoutMs, 1e3));
 			const output = await route.handler(ctx, input, signal);
 			return {
 				statusCode: 200,
-				headers: { "content-type": "application/json" },
+				headers: JSON_HDR,
 				body: JSON.stringify(output)
 			};
 		} catch (error) {
-			if (error instanceof ValidationError) return {
-				statusCode: 400,
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({
-					code: "BAD_REQUEST",
-					status: 400,
-					message: error.message,
-					data: { issues: error.issues }
-				})
-			};
-			const e = error instanceof SilgiError ? error : toSilgiError(error);
+			const body = serializeError(error);
 			return {
-				statusCode: e.status,
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify(e.toJSON())
+				statusCode: body.status,
+				headers: JSON_HDR,
+				body: JSON.stringify(body)
 			};
 		}
 	};
 }
 //#endregion
-export { silgiLambda };
+export { createHandler };

package/dist/adapters/express.d.mts

@@ -11,6 +11,6 @@ interface ExpressAdapterOptions<TCtx extends Record<string, unknown>> {
  * Mount at a prefix — the remainder of the path is the procedure name.
  * Requires `express.json()` middleware for POST body parsing.
  */
-declare function silgiExpress<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
 //#endregion
-export { ExpressAdapterOptions, silgiExpress };
+export { ExpressAdapterOptions, createHandler };

package/dist/adapters/express.mjs

@@ -1,6 +1,6 @@
-import { SilgiError, toSilgiError } from "../core/error.mjs";
-import { ValidationError } from "../core/schema.mjs";
 import { compileRouter } from "../compile.mjs";
+import { buildContext, isMethodAllowed, serializeError } from "../core/dispatch.mjs";
+import { iteratorToEventStream } from "../core/sse.mjs";
 //#region src/adapters/express.ts
 /**
 * Express adapter — use Silgi as Express middleware.
@@ -8,10 +8,10 @@ import { compileRouter } from "../compile.mjs";
 * @example
 * ```ts
 * import express from "express"
-* import { silgiExpress } from "silgi/express"
+* import { createHandler } from "silgi/express"
 *
 * const app = express()
-* app.use("/rpc", silgiExpress(appRouter, {
+* app.use("/rpc", createHandler(appRouter, {
 *   context: (req) => ({ db: getDB(), user: req.user }),
 * }))
 * app.listen(3000)
@@ -23,7 +23,7 @@ import { compileRouter } from "../compile.mjs";
 * Mount at a prefix — the remainder of the path is the procedure name.
 * Requires `express.json()` middleware for POST body parsing.
 */
-function silgiExpress(router, options = {}) {
+function createHandler(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	return (req, res, next) => {
 		let pathname = req.path ?? req.url ?? "";
@@ -31,15 +31,17 @@ function silgiExpress(router, options = {}) {
 		const match = flatRouter(req.method, "/" + pathname);
 		if (!match) return next();
 		const route = match.data;
+		if (!isMethodAllowed(req.method, route.method)) {
+			res.status(405).set("allow", route.method).json({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${req.method} not allowed`
+			});
+			return;
+		}
 		const handle = async () => {
 			try {
-				const ctx = Object.create(null);
-				if (match.params) ctx.params = match.params;
-				if (options.context) {
-					const baseCtx = await options.context(req);
-					const keys = Object.keys(baseCtx);
-					for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
-				}
+				const ctx = buildContext(options.context ? await options.context(req) : void 0, match.params);
 				let input;
 				if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") input = req.body;
 				else if (req.query?.data) if (typeof req.query.data === "string") try {
@@ -54,25 +56,65 @@ function silgiExpress(router, options = {}) {
 				}
 				else input = req.query.data;
 				const ac = new AbortController();
-				req.on("close", () => ac.abort());
-				const output = await route.handler(ctx, input, ac.signal);
-				res.json(output);
-			} catch (error) {
-				if (error instanceof ValidationError) {
-					res.status(400).json({
-						code: "BAD_REQUEST",
-						status: 400,
-						message: error.message,
-						data: { issues: error.issues }
-					});
-					return;
+				const onClose = () => ac.abort();
+				req.on("close", onClose);
+				try {
+					const output = await route.handler(ctx, input, ac.signal);
+					if (output instanceof Response) {
+						res.status(output.status);
+						output.headers.forEach((v, k) => res.setHeader(k, v));
+						const body = output.body ? Buffer.from(await output.arrayBuffer()) : "";
+						res.end(body);
+					} else if (output instanceof ReadableStream) {
+						res.setHeader("content-type", "application/octet-stream");
+						const reader = output.getReader();
+						req.on("close", () => reader.cancel());
+						try {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						} finally {
+							reader.releaseLock();
+						}
+					} else if (output && typeof output === "object" && Symbol.asyncIterator in output) {
+						const stream = iteratorToEventStream(output);
+						res.setHeader("content-type", "text/event-stream");
+						res.setHeader("cache-control", "no-cache");
+						const reader = stream.getReader();
+						req.on("close", () => reader.cancel());
+						try {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						} finally {
+							reader.releaseLock();
+						}
+					} else res.json(output);
+				} finally {
+					req.removeListener("close", onClose);
 				}
-				const e = error instanceof SilgiError ? error : toSilgiError(error);
-				res.status(e.status).json(e.toJSON());
+			} catch (error) {
+				const body = serializeError(error);
+				res.status(body.status).json(body);
 			}
 		};
-		handle();
+		handle().catch((error) => {
+			if (!res.headersSent) {
+				const body = serializeError(error);
+				res.status(body.status).json(body);
+			}
+		});
 	};
 }
 //#endregion
-export { silgiExpress };
+export { createHandler };

package/dist/adapters/message-port.d.mts

@@ -10,7 +10,7 @@ interface MessagePortAdapterOptions<TCtx extends Record<string, unknown>> {
  * Listens for RPC messages and responds with results.
  * Returns a dispose function to stop listening.
  */
-declare function silgiMessagePort<TCtx extends Record<string, unknown>>(router: RouterDef, port: {
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, port: {
   postMessage(msg: unknown): void;
   addEventListener(type: 'message', handler: (event: {
     data: unknown;
@@ -30,8 +30,13 @@ declare class MessagePortLink<TCtx extends ClientContext = ClientContext> implem
     addEventListener(type: 'message', handler: (event: {
       data: unknown;
     }) => void): void;
+    removeEventListener?(type: 'message', handler: (event: {
+      data: unknown;
+    }) => void): void;
   });
-  call(path: readonly string[], input: unknown, _options: ClientOptions<TCtx>): Promise<unknown>;
+  call(path: readonly string[], input: unknown, options: ClientOptions<TCtx>): Promise<unknown>;
+  /** Reject all pending calls and stop listening. */
+  dispose(): void;
 }
 //#endregion
-export { MessagePortAdapterOptions, MessagePortLink, silgiMessagePort };
+export { MessagePortAdapterOptions, MessagePortLink, createHandler };

package/dist/adapters/message-port.mjs

@@ -1,6 +1,6 @@
-import { SilgiError, toSilgiError } from "../core/error.mjs";
-import { ValidationError } from "../core/schema.mjs";
+import { SilgiError } from "../core/error.mjs";
 import { compileRouter } from "../compile.mjs";
+import { buildContext, serializeError } from "../core/dispatch.mjs";
 //#region src/adapters/message-port.ts
 /**
 * Message Port adapter — use Silgi over MessagePort/MessageChannel.
@@ -11,9 +11,9 @@ import { compileRouter } from "../compile.mjs";
 * @example
 * ```ts
 * // Worker / Electron main
-* import { silgiMessagePort } from "silgi/message-port"
+* import { createHandler } from "silgi/message-port"
 *
-* const dispose = silgiMessagePort(appRouter, port, {
+* const dispose = createHandler(appRouter, port, {
 *   context: () => ({ db: getDB() }),
 * })
 *
@@ -30,7 +30,7 @@ import { compileRouter } from "../compile.mjs";
 * Listens for RPC messages and responds with results.
 * Returns a dispose function to stop listening.
 */
-function silgiMessagePort(router, port, options = {}) {
+function createHandler(router, port, options = {}) {
 	const flatRouter = compileRouter(router);
 	const handler = async (event) => {
 		const msg = event.data;
@@ -51,15 +51,9 @@ function silgiMessagePort(router, port, options = {}) {
 		}
 		const route = match.data;
 		try {
-			const ctx = Object.create(null);
-			if (match.params) ctx.params = match.params;
-			if (options.context) {
-				const baseCtx = await options.context();
-				const keys = Object.keys(baseCtx);
-				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
-			}
-			const signal = new AbortController().signal;
-			const result = await route.handler(ctx, msg.input, signal);
+			const ctx = buildContext(options.context ? await options.context() : void 0, match.params);
+			const ac = new AbortController();
+			const result = await route.handler(ctx, msg.input, ac.signal);
 			port.postMessage({
 				__silgi: true,
 				__type: "response",
@@ -67,17 +61,11 @@ function silgiMessagePort(router, port, options = {}) {
 				result
 			});
 		} catch (error) {
-			const e = error instanceof ValidationError ? {
-				code: "BAD_REQUEST",
-				status: 400,
-				message: error.message,
-				data: { issues: error.issues }
-			} : error instanceof SilgiError ? error.toJSON() : toSilgiError(error).toJSON();
 			port.postMessage({
 				__silgi: true,
 				__type: "response",
 				id: msg.id,
-				error: e
+				error: serializeError(error)
 			});
 		}
 	};
@@ -92,9 +80,10 @@ var MessagePortLink = class {
 	#port;
 	#pending = /* @__PURE__ */ new Map();
 	#nextId = 1;
+	#messageHandler;
 	constructor(port) {
 		this.#port = port;
-		port.addEventListener("message", (event) => {
+		this.#messageHandler = (event) => {
 			const msg = event.data;
 			if (!msg || typeof msg !== "object" || !msg.__silgi || msg.__type !== "response") return;
 			const pending = this.#pending.get(msg.id);
@@ -106,15 +95,23 @@ var MessagePortLink = class {
 				data: msg.error.data
 			}));
 			else pending.resolve(msg.result);
-		});
+		};
+		port.addEventListener("message", this.#messageHandler);
 	}
-	call(path, input, _options) {
+	call(path, input, options) {
 		return new Promise((resolve, reject) => {
 			const id = String(this.#nextId++);
 			this.#pending.set(id, {
 				resolve,
 				reject
 			});
+			if (options.signal) options.signal.addEventListener("abort", () => {
+				const pending = this.#pending.get(id);
+				if (pending) {
+					this.#pending.delete(id);
+					pending.reject(new DOMException("Aborted", "AbortError"));
+				}
+			}, { once: true });
 			this.#port.postMessage({
 				__silgi: true,
 				__type: "request",
@@ -124,6 +121,12 @@ var MessagePortLink = class {
 			});
 		});
 	}
+	/** Reject all pending calls and stop listening. */
+	dispose() {
+		for (const [, pending] of this.#pending) pending.reject(new DOMException("Link disposed", "AbortError"));
+		this.#pending.clear();
+		this.#port.removeEventListener?.("message", this.#messageHandler);
+	}
 };
 //#endregion
-export { MessagePortLink, silgiMessagePort };
+export { MessagePortLink, createHandler };

package/dist/adapters/nestjs.d.mts

@@ -11,15 +11,15 @@ interface NestAdapterOptions<TCtx extends Record<string, unknown>> {
  * Use inside a `@Controller` with `@All("*")`.
  * Handles routing internally — NestJS only needs to mount the prefix.
  */
-declare function silgiNestHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NestAdapterOptions<TCtx>): (req: any, res: any) => Promise<void>;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NestAdapterOptions<TCtx>): (req: any, res: any) => Promise<void>;
 /**
  * Create a NestJS module configuration for Silgi.
  *
  * Returns an object that can be used with NestJS's dynamic module pattern.
  */
-declare function createSilgiModule(router: RouterDef, options?: NestAdapterOptions<any>): {
+declare function createModule(router: RouterDef, options?: NestAdapterOptions<any>): {
   handler: (req: any, res: any) => Promise<void>;
   router: RouterDef;
 };
 //#endregion
-export { NestAdapterOptions, createSilgiModule, silgiNestHandler };
+export { NestAdapterOptions, createHandler, createModule };