@fragno-dev/core 0.1.7 → 0.1.8

package/dist/fragment-instantiation-DUT-HLl1.js

@@ -0,0 +1,898 @@
+import { r as resolveRouteFactories } from "./route-C4CyNHkC.js";
+import { addRoute, createRouter, findRoute } from "rou3";
+
+//#region src/api/error.ts
+var FragnoApiError = class extends Error {
+	#status;
+	#code;
+	constructor({ message, code }, status) {
+		super(message);
+		this.name = "FragnoApiError";
+		this.#status = status;
+		this.#code = code;
+	}
+	get status() {
+		return this.#status;
+	}
+	get code() {
+		return this.#code;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+var FragnoApiValidationError = class extends FragnoApiError {
+	#issues;
+	constructor(message, issues) {
+		super({
+			message,
+			code: "FRAGNO_VALIDATION_ERROR"
+		}, 400);
+		this.name = "FragnoApiValidationError";
+		this.#issues = issues;
+	}
+	get issues() {
+		return this.#issues;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			issues: this.#issues,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+
+//#endregion
+//#region src/api/api.ts
+function addRoute$1(route) {
+	return route;
+}
+
+//#endregion
+//#region src/api/internal/route.ts
+function getMountRoute(opts) {
+	const mountRoute = opts.mountRoute ?? `/api/${opts.name}`;
+	if (mountRoute.endsWith("/")) return mountRoute.slice(0, -1);
+	return mountRoute;
+}
+
+//#endregion
+//#region src/api/request-input-context.ts
+var RequestInputContext = class RequestInputContext {
+	#path;
+	#method;
+	#pathParams;
+	#searchParams;
+	#headers;
+	#body;
+	#parsedBody;
+	#inputSchema;
+	#shouldValidateInput;
+	constructor(config) {
+		this.#path = config.path;
+		this.#method = config.method;
+		this.#pathParams = config.pathParams;
+		this.#searchParams = config.searchParams;
+		this.#headers = config.headers;
+		this.#body = config.rawBody;
+		this.#parsedBody = config.parsedBody;
+		this.#inputSchema = config.inputSchema;
+		this.#shouldValidateInput = config.shouldValidateInput ?? true;
+	}
+	/**
+	* Create a RequestContext from a Request object for server-side handling
+	*/
+	static async fromRequest(config) {
+		return new RequestInputContext({
+			method: config.method,
+			path: config.path,
+			pathParams: config.state.pathParams,
+			searchParams: config.state.searchParams,
+			headers: config.state.headers,
+			parsedBody: config.state.body,
+			rawBody: config.rawBody,
+			inputSchema: config.inputSchema,
+			shouldValidateInput: config.shouldValidateInput
+		});
+	}
+	/**
+	* Create a RequestContext for server-side rendering contexts (no Request object)
+	*/
+	static fromSSRContext(config) {
+		return new RequestInputContext({
+			method: config.method,
+			path: config.path,
+			pathParams: config.pathParams,
+			searchParams: config.searchParams ?? new URLSearchParams(),
+			headers: config.headers ?? new Headers(),
+			parsedBody: "body" in config ? config.body : void 0,
+			inputSchema: "inputSchema" in config ? config.inputSchema : void 0,
+			shouldValidateInput: false
+		});
+	}
+	/**
+	* The HTTP method as string (e.g., `GET`, `POST`)
+	*/
+	get method() {
+		return this.#method;
+	}
+	/**
+	* The matched route path (e.g., `/users/:id`)
+	* @remarks `string`
+	*/
+	get path() {
+		return this.#path;
+	}
+	/**
+	* Extracted path parameters as object (e.g., `{ id: '123' }`)
+	* @remarks `Record<string, string>`
+	*/
+	get pathParams() {
+		return this.#pathParams;
+	}
+	/**
+	* [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+	* @remarks `URLSearchParams`
+	*/
+	get query() {
+		return this.#searchParams;
+	}
+	/**
+	* [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+	* @remarks `Headers`
+	*/
+	get headers() {
+		return this.#headers;
+	}
+	get rawBody() {
+		return this.#body;
+	}
+	/**
+	* Input validation context (only if inputSchema is defined)
+	* @remarks `InputContext`
+	*/
+	get input() {
+		if (!this.#inputSchema) return;
+		return {
+			schema: this.#inputSchema,
+			valid: async () => {
+				if (!this.#shouldValidateInput) return this.#parsedBody;
+				return this.#validateInput();
+			}
+		};
+	}
+	async #validateInput() {
+		if (!this.#inputSchema) throw new Error("No input schema defined for this route");
+		if (this.#parsedBody instanceof FormData || this.#parsedBody instanceof Blob) throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
+		const result = await this.#inputSchema["~standard"].validate(this.#parsedBody);
+		if (result.issues) throw new FragnoApiValidationError("Validation failed", result.issues);
+		return result.value;
+	}
+};
+
+//#endregion
+//#region src/api/internal/response-stream.ts
+var ResponseStream = class {
+	#writer;
+	#encoder;
+	#abortSubscribers = [];
+	#responseReadable;
+	#aborted = false;
+	#closed = false;
+	/**
+	* Whether the stream has been aborted.
+	*/
+	get aborted() {
+		return this.#aborted;
+	}
+	/**
+	* Whether the stream has been closed normally.
+	*/
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* The readable stream that the response is piped to.
+	*/
+	get responseReadable() {
+		return this.#responseReadable;
+	}
+	constructor(writable, readable) {
+		this.#writer = writable.getWriter();
+		this.#encoder = new TextEncoder();
+		const reader = readable.getReader();
+		this.#abortSubscribers.push(async () => {
+			await reader.cancel();
+		});
+		this.#responseReadable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			},
+			cancel: () => {
+				this.abort();
+			}
+		});
+	}
+	async writeRaw(input) {
+		try {
+			if (typeof input === "string") input = this.#encoder.encode(input);
+			await this.#writer.write(input);
+		} catch {}
+	}
+	write(input) {
+		return this.writeRaw(JSON.stringify(input) + "\n");
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async close() {
+		try {
+			await this.#writer.close();
+		} catch {} finally {
+			this.#closed = true;
+		}
+	}
+	onAbort(listener) {
+		this.#abortSubscribers.push(listener);
+	}
+	/**
+	* Abort the stream.
+	* You can call this method when stream is aborted by external event.
+	*/
+	abort() {
+		if (!this.aborted) {
+			this.#aborted = true;
+			this.#abortSubscribers.forEach((subscriber) => subscriber());
+		}
+	}
+};
+
+//#endregion
+//#region src/api/request-output-context.ts
+/**
+* Utility function to merge headers from multiple sources.
+* Later headers override earlier ones.
+*/
+function mergeHeaders(...headerSources) {
+	const mergedHeaders = new Headers();
+	for (const headerSource of headerSources) {
+		if (!headerSource) continue;
+		if (headerSource instanceof Headers) for (const [key, value] of headerSource.entries()) mergedHeaders.set(key, value);
+		else if (Array.isArray(headerSource)) for (const [key, value] of headerSource) mergedHeaders.set(key, value);
+		else for (const [key, value] of Object.entries(headerSource)) mergedHeaders.set(key, value);
+	}
+	return mergedHeaders;
+}
+var OutputContext = class {
+	/**
+	* Creates an error response.
+	*
+	* Shortcut for `throw new FragnoApiError(...)`
+	*/
+	error = ({ message, code }, initOrStatus, headers) => {
+		if (typeof initOrStatus === "undefined") return Response.json({
+			message,
+			code
+		}, {
+			status: 500,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders(initOrStatus.headers, headers);
+		return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	empty = (initOrStatus, headers) => {
+		const defaultHeaders = {};
+		if (typeof initOrStatus === "undefined") {
+			const mergedHeaders$1 = mergeHeaders(defaultHeaders, headers);
+			return new Response(null, {
+				status: 201,
+				headers: mergedHeaders$1
+			});
+		}
+		if (typeof initOrStatus === "number") {
+			const mergedHeaders$1 = mergeHeaders(defaultHeaders, headers);
+			return new Response(null, {
+				status: initOrStatus,
+				headers: mergedHeaders$1
+			});
+		}
+		const mergedHeaders = mergeHeaders(defaultHeaders, initOrStatus.headers, headers);
+		return new Response(null, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	json = (object, initOrStatus, headers) => {
+		if (typeof initOrStatus === "undefined") return Response.json(object, {
+			status: 200,
+			headers
+		});
+		if (typeof initOrStatus === "number") return Response.json(object, {
+			status: initOrStatus,
+			headers
+		});
+		const mergedHeaders = mergeHeaders(initOrStatus.headers, headers);
+		return Response.json(object, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	jsonStream = (cb, { onError, headers } = {}) => {
+		const defaultHeaders = {
+			"content-type": "application/x-ndjson; charset=utf-8",
+			"transfer-encoding": "chunked",
+			"cache-control": "no-cache"
+		};
+		const { readable, writable } = new TransformStream();
+		const stream = new ResponseStream(writable, readable);
+		(async () => {
+			try {
+				await cb(stream);
+			} catch (e) {
+				if (e === void 0) {} else if (e instanceof Error && onError) await onError(e, stream);
+				else console.error(e);
+			} finally {
+				stream.close();
+			}
+		})();
+		return new Response(stream.responseReadable, {
+			status: 200,
+			headers: mergeHeaders(defaultHeaders, headers)
+		});
+	};
+};
+var RequestOutputContext = class extends OutputContext {
+	#outputSchema;
+	constructor(outputSchema) {
+		super();
+		this.#outputSchema = outputSchema;
+	}
+};
+
+//#endregion
+//#region src/api/mutable-request-state.ts
+/**
+* Holds mutable request state that can be modified by middleware and consumed by handlers.
+*
+* This class provides a structural way for middleware to modify request data:
+* - Path parameters can be modified
+* - Query/search parameters can be modified
+* - Request body can be overridden
+* - Request headers can be modified
+*
+* @example
+* ```typescript
+* // In middleware
+* const state = new MutableRequestState({
+*   pathParams: { id: "123" },
+*   searchParams: new URLSearchParams("?role=user"),
+*   body: { name: "John" },
+*   headers: new Headers()
+* });
+*
+* // Modify query parameters
+* state.searchParams.set("role", "admin");
+*
+* // Override body
+* state.setBody({ name: "Jane" });
+*
+* // Modify headers
+* state.headers.set("X-Custom", "value");
+* ```
+*/
+var MutableRequestState = class {
+	#pathParams;
+	#searchParams;
+	#headers;
+	#initialBody;
+	#bodyOverride;
+	constructor(config) {
+		this.#pathParams = config.pathParams;
+		this.#searchParams = config.searchParams;
+		this.#headers = config.headers;
+		this.#initialBody = config.body;
+		this.#bodyOverride = void 0;
+	}
+	/**
+	* Path parameters extracted from the route.
+	* Can be modified directly (e.g., `state.pathParams.id = "456"`).
+	*/
+	get pathParams() {
+		return this.#pathParams;
+	}
+	/**
+	* URLSearchParams for query parameters.
+	* Can be modified using URLSearchParams API (e.g., `state.searchParams.set("key", "value")`).
+	*/
+	get searchParams() {
+		return this.#searchParams;
+	}
+	/**
+	* Request headers.
+	* Can be modified using Headers API (e.g., `state.headers.set("X-Custom", "value")`).
+	*/
+	get headers() {
+		return this.#headers;
+	}
+	/**
+	* Get the current body value.
+	* Returns the override if set, otherwise the initial body.
+	*/
+	get body() {
+		return this.#bodyOverride !== void 0 ? this.#bodyOverride : this.#initialBody;
+	}
+	/**
+	* Override the request body.
+	* This allows middleware to replace the body that will be seen by the handler.
+	*
+	* @param body - The new body value
+	*
+	* @example
+	* ```typescript
+	* // In middleware
+	* state.setBody({ modifiedField: "new value" });
+	* ```
+	*/
+	setBody(body) {
+		this.#bodyOverride = body;
+	}
+	/**
+	* Check if the body has been overridden by middleware.
+	*/
+	get hasBodyOverride() {
+		return this.#bodyOverride !== void 0;
+	}
+};
+
+//#endregion
+//#region src/api/request-middleware.ts
+var RequestMiddlewareOutputContext = class extends OutputContext {
+	#deps;
+	#services;
+	constructor(deps, services) {
+		super();
+		this.#deps = deps;
+		this.#services = services;
+	}
+	get deps() {
+		return this.#deps;
+	}
+	get services() {
+		return this.#services;
+	}
+};
+var RequestMiddlewareInputContext = class {
+	#options;
+	#route;
+	#state;
+	constructor(routes, options) {
+		this.#options = options;
+		this.#state = options.state;
+		const route = routes.find((route$1) => route$1.path === options.path && route$1.method === options.method);
+		if (!route) throw new Error(`Route not found: ${options.path} ${options.method}`);
+		this.#route = route;
+	}
+	get path() {
+		return this.#options.path;
+	}
+	get method() {
+		return this.#options.method;
+	}
+	get pathParams() {
+		return this.#state.pathParams;
+	}
+	get queryParams() {
+		return this.#state.searchParams;
+	}
+	get headers() {
+		return this.#state.headers;
+	}
+	get inputSchema() {
+		return this.#route.inputSchema;
+	}
+	get outputSchema() {
+		return this.#route.outputSchema;
+	}
+	/**
+	* Access to the mutable request state.
+	* Use this to modify query parameters, path parameters, or request body.
+	*
+	* @example
+	* ```typescript
+	* // Modify body
+	* requestState.setBody({ modified: true });
+	*
+	* // Query params are already accessible via queryParams getter
+	* // Path params are already accessible via pathParams getter
+	* ```
+	*/
+	get requestState() {
+		return this.#state;
+	}
+	ifMatchesRoute = async (method, path, handler) => {
+		if (this.path !== path || this.method !== method) return;
+		return await handler(await RequestInputContext.fromRequest({
+			request: this.#options.request,
+			method: this.#options.method,
+			path,
+			pathParams: this.pathParams,
+			inputSchema: this.#route.inputSchema,
+			state: this.#state
+		}), new RequestOutputContext(this.#route.outputSchema));
+	};
+};
+
+//#endregion
+//#region src/api/fragno-response.ts
+/**
+* Parse a Response object into a FragnoResponse discriminated union
+*/
+async function parseFragnoResponse(response) {
+	const status = response.status;
+	const headers = response.headers;
+	if ((headers.get("content-type") || "").includes("application/x-ndjson")) return {
+		type: "jsonStream",
+		status,
+		headers,
+		stream: parseNDJSONStream(response)
+	};
+	const text = await response.text();
+	if (!text || text === "null") return {
+		type: "empty",
+		status,
+		headers
+	};
+	const data = JSON.parse(text);
+	if (data && typeof data === "object" && "code" in data) {
+		if ("message" in data) return {
+			type: "error",
+			status,
+			headers,
+			error: {
+				message: data.message,
+				code: data.code
+			}
+		};
+		if ("error" in data) return {
+			type: "error",
+			status,
+			headers,
+			error: {
+				message: data.error,
+				code: data.code
+			}
+		};
+	}
+	return {
+		type: "json",
+		status,
+		headers,
+		data
+	};
+}
+/**
+* Parse an NDJSON stream into an async generator
+*/
+async function* parseNDJSONStream(response) {
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) if (line.trim()) yield JSON.parse(line);
+		}
+		if (buffer.trim()) yield JSON.parse(buffer);
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+//#endregion
+//#region src/api/fragment-instantiation.ts
+const instantiatedFragmentFakeSymbol = "$fragno-instantiated-fragment";
+function createFragment(fragmentBuilder, config, routesOrFactories, options, interfaceImplementations) {
+	const definition = fragmentBuilder.definition;
+	if (definition.usedServices) for (const [serviceName, serviceMeta] of Object.entries(definition.usedServices)) {
+		const implementation = interfaceImplementations?.[serviceName];
+		if (serviceMeta.required && !implementation) throw new Error(`Fragment '${definition.name}' requires service '${serviceMeta.name}' but it was not provided`);
+	}
+	const depsWithInterfaces = {
+		...definition.dependencies?.(config, options) ?? {},
+		...interfaceImplementations
+	};
+	const servicesFromWithServices = definition.services?.(config, options, depsWithInterfaces) ?? {};
+	let providedServicesResolved;
+	if (typeof definition.providedServices === "function") providedServicesResolved = definition.providedServices(config, options, depsWithInterfaces);
+	else if (definition.providedServices && typeof definition.providedServices === "object") {
+		providedServicesResolved = {};
+		for (const [serviceName, serviceOrFactory] of Object.entries(definition.providedServices)) if (typeof serviceOrFactory === "function") providedServicesResolved[serviceName] = serviceOrFactory(config, options, depsWithInterfaces);
+		else providedServicesResolved[serviceName] = serviceOrFactory;
+	}
+	const services = {
+		...servicesFromWithServices,
+		...providedServicesResolved,
+		...interfaceImplementations
+	};
+	const routes = resolveRouteFactories({
+		config,
+		deps: depsWithInterfaces,
+		services
+	}, routesOrFactories);
+	const mountRoute = getMountRoute({
+		name: definition.name,
+		mountRoute: options.mountRoute
+	});
+	const router = createRouter();
+	let middlewareHandler;
+	const handlerWrapper = definition.createHandlerWrapper?.(options);
+	for (const routeConfig of routes) addRoute(router, routeConfig.method.toUpperCase(), routeConfig.path, routeConfig);
+	const fragment = {
+		[instantiatedFragmentFakeSymbol]: instantiatedFragmentFakeSymbol,
+		mountRoute,
+		config: {
+			name: definition.name,
+			routes
+		},
+		services,
+		deps: depsWithInterfaces,
+		additionalContext: {
+			...definition.additionalContext,
+			...options
+		},
+		withMiddleware: (handler) => {
+			if (middlewareHandler) throw new Error("Middleware already set");
+			middlewareHandler = handler;
+			return fragment;
+		},
+		callRoute: async (method, path, inputOptions) => {
+			return parseFragnoResponse(await fragment.callRouteRaw(method, path, inputOptions));
+		},
+		callRouteRaw: async (method, path, inputOptions) => {
+			const route = routes.find((r) => r.method === method && r.path === path);
+			if (!route) return Response.json({
+				error: `Route ${method} ${path} not found`,
+				code: "ROUTE_NOT_FOUND"
+			}, { status: 404 });
+			const { pathParams = {}, body, query, headers } = inputOptions || {};
+			const searchParams = query instanceof URLSearchParams ? query : query ? new URLSearchParams(query) : new URLSearchParams();
+			const requestHeaders = headers instanceof Headers ? headers : headers ? new Headers(headers) : new Headers();
+			const inputContext = new RequestInputContext({
+				path: route.path,
+				method: route.method,
+				pathParams,
+				searchParams,
+				headers: requestHeaders,
+				parsedBody: body,
+				inputSchema: route.inputSchema,
+				shouldValidateInput: true
+			});
+			const outputContext = new RequestOutputContext(route.outputSchema);
+			try {
+				let response;
+				const thisContext = {};
+				if (handlerWrapper) response = await handlerWrapper(route.handler).call(thisContext, inputContext, outputContext);
+				else response = await route.handler.call(thisContext, inputContext, outputContext);
+				return response;
+			} catch (error) {
+				console.error("Error in callRoute handler", error);
+				if (error instanceof FragnoApiError) return error.toResponse();
+				return Response.json({
+					error: "Internal server error",
+					code: "INTERNAL_SERVER_ERROR"
+				}, { status: 500 });
+			}
+		},
+		handlersFor: (framework) => {
+			const handler = fragment.handler;
+			if (framework === "h3" || framework === "nuxt") throw new Error(`To get handlers for h3, use the 'fromWebHandler' utility function:
+          import { fromWebHandler } from "h3";
+          export default fromWebHandler(myFragment().handler);`);
+			return {
+				astro: { ALL: handler },
+				"react-router": {
+					loader: ({ request }) => handler(request),
+					action: ({ request }) => handler(request)
+				},
+				"next-js": {
+					GET: handler,
+					POST: handler,
+					PUT: handler,
+					DELETE: handler,
+					PATCH: handler,
+					HEAD: handler,
+					OPTIONS: handler
+				},
+				"svelte-kit": {
+					GET: handler,
+					POST: handler,
+					PUT: handler,
+					DELETE: handler,
+					PATCH: handler,
+					HEAD: handler,
+					OPTIONS: handler
+				},
+				"solid-start": {
+					GET: ({ request }) => handler(request),
+					POST: ({ request }) => handler(request),
+					PUT: ({ request }) => handler(request),
+					DELETE: ({ request }) => handler(request),
+					PATCH: ({ request }) => handler(request),
+					HEAD: ({ request }) => handler(request),
+					OPTIONS: ({ request }) => handler(request)
+				},
+				"tanstack-start": {
+					GET: ({ request }) => handler(request),
+					POST: ({ request }) => handler(request),
+					PUT: ({ request }) => handler(request),
+					DELETE: ({ request }) => handler(request),
+					PATCH: ({ request }) => handler(request),
+					HEAD: ({ request }) => handler(request),
+					OPTIONS: ({ request }) => handler(request)
+				}
+			}[framework];
+		},
+		handler: async (req) => {
+			const url = new URL(req.url);
+			const pathname = url.pathname;
+			const matchRoute = pathname.startsWith(mountRoute) ? pathname.slice(mountRoute.length) : null;
+			if (matchRoute === null) return Response.json({
+				error: `Fragno: Route for '${definition.name}' not found. Is the fragment mounted on the right route? Expecting: '${mountRoute}'.`,
+				code: "ROUTE_NOT_FOUND"
+			}, { status: 404 });
+			const route = findRoute(router, req.method, matchRoute);
+			if (!route) return Response.json({
+				error: `Fragno: Route for '${definition.name}' not found`,
+				code: "ROUTE_NOT_FOUND"
+			}, { status: 404 });
+			const { handler, inputSchema, outputSchema, path } = route.data;
+			const outputContext = new RequestOutputContext(outputSchema);
+			let requestBody = void 0;
+			let rawBody = void 0;
+			if (req.body instanceof ReadableStream) {
+				rawBody = await req.clone().text();
+				if (rawBody) try {
+					requestBody = JSON.parse(rawBody);
+				} catch {
+					requestBody = void 0;
+				}
+			}
+			const requestState = new MutableRequestState({
+				pathParams: route.params ?? {},
+				searchParams: url.searchParams,
+				body: requestBody,
+				headers: new Headers(req.headers)
+			});
+			if (middlewareHandler) {
+				const middlewareInputContext = new RequestMiddlewareInputContext(routes, {
+					method: req.method,
+					path,
+					request: req,
+					state: requestState
+				});
+				const middlewareOutputContext = new RequestMiddlewareOutputContext(depsWithInterfaces, services);
+				try {
+					const middlewareResult = await middlewareHandler(middlewareInputContext, middlewareOutputContext);
+					if (middlewareResult !== void 0) return middlewareResult;
+				} catch (error) {
+					console.error("Error in middleware", error);
+					if (error instanceof FragnoApiError) return error.toResponse();
+					return Response.json({
+						error: "Internal server error",
+						code: "INTERNAL_SERVER_ERROR"
+					}, { status: 500 });
+				}
+			}
+			const inputContext = await RequestInputContext.fromRequest({
+				request: req,
+				method: req.method,
+				path,
+				pathParams: route.params ?? {},
+				inputSchema,
+				state: requestState,
+				rawBody
+			});
+			try {
+				return await (handlerWrapper ? handlerWrapper(handler) : handler).call({}, inputContext, outputContext);
+			} catch (error) {
+				console.error("Error in handler", error);
+				if (error instanceof FragnoApiError) return error.toResponse();
+				return Response.json({
+					error: "Internal server error",
+					code: "INTERNAL_SERVER_ERROR"
+				}, { status: 500 });
+			}
+		}
+	};
+	return fragment;
+}
+/**
+* Builder class for fluent fragment instantiation API
+*/
+var FragmentInstantiationBuilder = class {
+	#fragmentBuilder;
+	#config;
+	#routes;
+	#options;
+	#services;
+	constructor(fragmentBuilder) {
+		this.#fragmentBuilder = fragmentBuilder;
+	}
+	/**
+	* Set the configuration for the fragment
+	*/
+	withConfig(config) {
+		this.#config = config;
+		return this;
+	}
+	/**
+	* Set the routes for the fragment
+	*/
+	withRoutes(routes) {
+		this.#routes = routes;
+		return this;
+	}
+	/**
+	* Set the options for the fragment (e.g., mountRoute, databaseAdapter)
+	*/
+	withOptions(options) {
+		this.#options = options;
+		return this;
+	}
+	/**
+	* Provide implementations for services that this fragment uses
+	*/
+	withServices(services) {
+		this.#services = services;
+		return this;
+	}
+	/**
+	* Build and return the instantiated fragment
+	*/
+	build() {
+		return createFragment(this.#fragmentBuilder, this.#config ?? {}, this.#routes ?? [], this.#options ?? {}, this.#services);
+	}
+};
+/**
+* Create a fluent builder for instantiating a fragment
+*
+* @example
+* ```ts
+* const fragment = instantiateFragment(myFragmentBuilder)
+*   .withConfig({ apiKey: "key" })
+*   .withRoutes([route1, route2])
+*   .withOptions({ mountRoute: "/api" })
+*   .build();
+* ```
+*/
+function instantiateFragment(fragmentBuilder) {
+	return new FragmentInstantiationBuilder(fragmentBuilder);
+}
+
+//#endregion
+export { RequestOutputContext as a, addRoute$1 as c, instantiatedFragmentFakeSymbol as i, FragnoApiError as l, createFragment as n, RequestInputContext as o, instantiateFragment as r, getMountRoute as s, FragmentInstantiationBuilder as t, FragnoApiValidationError as u };
+//# sourceMappingURL=fragment-instantiation-DUT-HLl1.js.map