@sx3/ultra 0.0.1

package/dist/session.d.mts

@@ -0,0 +1,115 @@
+import { n as DefaultSocketData, r as HTTPContext, t as BaseContext } from "./context-ChCsZh7S.mjs";
+import { a as JSONValue, o as Promisable, r as JSONObject, t as DeepReadonly } from "./types-Cn69QrjS.mjs";
+import "./http-BqWCMASL.mjs";
+import "./middleware-COKreBGP.mjs";
+import { ProceduresMap, Ultra } from "./ultra.mjs";
+import { BunRequest, CookieSameSite, RedisClient } from "bun";
+
+//#region src/session.d.ts
+type SessionData = Record<string, JSONValue>;
+/** Session store interface */
+interface SessionStore {
+  read: (sessionId: string) => Promisable<SessionData | null>;
+  write: (sessionId: string, data: SessionData) => Promisable<void>;
+  destroy: (sessionId: string) => Promisable<void>;
+  touch: (sessionId: string) => Promisable<void>;
+}
+/** Options user for set session cookie */
+interface SessionCookieOptions {
+  /** @default "/" */
+  path: string;
+  /** @default true */
+  httpOnly: boolean;
+  /** @default true */
+  secure: boolean;
+  /** @default "lax" */
+  sameSite: CookieSameSite;
+  /** In seconds. @default config.ttlSec */
+  maxAge: number;
+}
+/** Factory for create session store  */
+type SessionStoreFactory = (config: SessionConfig<any>, context: BaseContext) => SessionStore;
+interface SessionConfig<S extends Record<string, SessionStoreFactory> = Record<string, SessionStoreFactory>> {
+  /** The name is used as a prefix to cookies and storage with such as Redis  */
+  name: string;
+  /** Session time to live in seconds */
+  ttlSec: number;
+  /** Secret used to sign session ID cookie */
+  secret: string;
+  /** Options used to set session cookie */
+  cookie?: Partial<SessionCookieOptions>;
+  /** Default store */
+  store: Extract<keyof S, string>;
+  /** Available session stores as factories */
+  stores: S;
+}
+/** Session socket data extensions */
+interface SessionSocketData {
+  sessionId: string;
+}
+declare function defineConfig<S extends Record<string, SessionStoreFactory>>(config: SessionConfig<S>): SessionConfig<S>;
+/** Extends context and socket data, initiate session instance every request */
+declare function createSessionModule<S extends Record<string, SessionStoreFactory>>(config: SessionConfig<S>): Ultra<ProceduresMap, (BaseContext & {
+  session: Session<S>;
+}) & BaseContext, DefaultSocketData & ((context: HTTPContext) => {
+  sessionId: string;
+})>;
+/** Stores the ID in a cookie, then moves it to the socket and uses it for requests  */
+declare class Session<Stores extends Record<string, SessionStoreFactory> = Record<string, SessionStoreFactory>> {
+  /** Make random session id */
+  static makeId(): string;
+  /** Get existing session ID from request cookie or create a new one */
+  static getOrCreateId(request: BunRequest, config: SessionConfig<any>): string;
+  protected readonly config: SessionConfig<Stores>;
+  protected readonly context: BaseContext;
+  protected readonly store: SessionStore;
+  protected readonly sessionIdFromClient: string | null;
+  protected sessionId: string;
+  protected sessionState: JSONObject | null;
+  protected modified: boolean;
+  constructor(config: SessionConfig<Stores>, context: BaseContext);
+  get id(): string;
+  /** Load data from session store */
+  initiate(): Promise<void>;
+  /** Commit data to session store */
+  commit(): Promise<void>;
+  /** Change session id */
+  regenerate(): void;
+  get<T extends JSONValue>(key: string): DeepReadonly<T> | null;
+  get<T extends JSONValue>(key: string, defaultValue: T): DeepReadonly<T>;
+  set(key: string, value: JSONValue): void;
+  has(key: string): boolean;
+  all(): DeepReadonly<JSONObject>;
+  delete(key: string): void;
+  clear(): void;
+  protected get state(): JSONObject;
+  protected get isEmpty(): boolean;
+  protected touch(): void;
+}
+declare class RedisSessionStore implements SessionStore {
+  protected readonly config: SessionConfig<any>;
+  protected readonly connection: RedisClient;
+  constructor(config: SessionConfig<any>, connection: RedisClient);
+  read(sessionId: string): Promise<SessionData | null>;
+  write(sessionId: string, data: SessionData): Promise<void>;
+  destroy(sessionId: string): Promise<void>;
+  touch(sessionId: string): Promise<void>;
+}
+declare class MemorySessionStore implements SessionStore {
+  protected readonly config: SessionConfig<any>;
+  protected readonly sessions: Map<string, {
+    data: SessionData;
+    touched: number;
+  }>;
+  protected readonly sweepIntervalMs: number;
+  protected readonly ttlMs: number;
+  protected lastSweepAt: number;
+  constructor(config: SessionConfig<any>, sweepIntervalSec?: number);
+  read(sessionId: string): SessionData | null;
+  write(sessionId: string, data: SessionData): void;
+  destroy(sessionId: string): void;
+  touch(sessionId: string): void;
+  protected maybeSweep(now?: number): void;
+}
+//#endregion
+export { MemorySessionStore, RedisSessionStore, Session, SessionConfig, SessionData, SessionSocketData, SessionStore, SessionStoreFactory, createSessionModule, defineConfig };

package/dist/session.mjs

@@ -0,0 +1,181 @@
+import { i as UnsupportedProtocolError } from "./error-CII1zMOR.mjs";
+import { Ultra } from "./ultra.mjs";
+import { isHTTP, isWS } from "./context.mjs";
+import { sign, unsign } from "./crypto.mjs";
+import { randomBytes } from "node:crypto";
+
+//#region src/session.ts
+function defineConfig(config) {
+	return {
+		...config,
+		cookie: {
+			path: "/",
+			httpOnly: true,
+			secure: true,
+			sameSite: "lax",
+			maxAge: config.ttlSec,
+			...config?.cookie
+		}
+	};
+}
+/** Extends context and socket data, initiate session instance every request */
+function createSessionModule(config) {
+	return new Ultra().deriveWS((context) => ({ sessionId: Session.getOrCreateId(context.request, config) })).derive((context) => ({ session: new Session(config, context) })).use(async ({ context, next }) => {
+		await context.session.initiate();
+		const response = await next();
+		await context.session.commit();
+		return response;
+	});
+}
+/** Stores the ID in a cookie, then moves it to the socket and uses it for requests  */
+var Session = class Session {
+	/** Make random session id */
+	static makeId() {
+		return randomBytes(16).toString("base64url");
+	}
+	/** Get existing session ID from request cookie or create a new one */
+	static getOrCreateId(request, config) {
+		const cookie = request.cookies.get(config.name);
+		if (cookie) return unsign(cookie, config.secret) || Session.makeId();
+		return Session.makeId();
+	}
+	config;
+	context;
+	store;
+	sessionIdFromClient = null;
+	sessionId;
+	sessionState = null;
+	modified = false;
+	constructor(config, context) {
+		this.config = config;
+		this.context = context;
+		this.store = config.stores[config.store](config, context);
+		switch (true) {
+			case isHTTP(context): {
+				const cookie = context.request.cookies.get(config.name);
+				if (cookie) this.sessionIdFromClient = unsign(cookie, config.secret);
+				break;
+			}
+			case isWS(context):
+				this.sessionIdFromClient = context.ws.data.sessionId || null;
+				break;
+			default: throw new UnsupportedProtocolError("Session management is only supported for HTTP and WebSocket protocols.");
+		}
+		this.sessionId = this.sessionIdFromClient || Session.makeId();
+	}
+	get id() {
+		return this.sessionId;
+	}
+	/** Load data from session store */
+	async initiate() {
+		if (this.sessionState) return;
+		this.sessionState = await this.store.read(this.sessionId) || {};
+	}
+	/** Commit data to session store */
+	async commit() {
+		this.touch();
+		if (this.isEmpty && this.sessionIdFromClient) return this.store.destroy(this.sessionIdFromClient);
+		if (this.sessionIdFromClient && this.sessionIdFromClient !== this.sessionId) {
+			await this.store.destroy(this.sessionIdFromClient);
+			await this.store.write(this.sessionId, this.state);
+		} else if (this.modified) await this.store.write(this.sessionId, this.state);
+		else await this.store.touch(this.sessionId);
+	}
+	/** Change session id */
+	regenerate() {
+		this.sessionId = Session.makeId();
+	}
+	get(key, defaultValue) {
+		return this.state[key] ?? defaultValue ?? null;
+	}
+	set(key, value) {
+		this.state[key] = value;
+		this.modified = true;
+	}
+	has(key) {
+		return Object.hasOwn(this.state, key);
+	}
+	all() {
+		return this.state;
+	}
+	delete(key) {
+		delete this.state[key];
+		this.modified = true;
+	}
+	clear() {
+		this.sessionState = {};
+		this.modified = true;
+	}
+	get state() {
+		if (!this.sessionState) throw new Error("Session is not initiated yet.");
+		return this.sessionState;
+	}
+	get isEmpty() {
+		return Object.keys(this.state).length === 0;
+	}
+	touch() {
+		if ("request" in this.context) this.context.request.cookies.set(this.config.name, sign(this.sessionId, this.config.secret), this.config.cookie);
+	}
+};
+var RedisSessionStore = class {
+	config;
+	connection;
+	constructor(config, connection) {
+		this.config = config;
+		this.connection = connection;
+	}
+	async read(sessionId) {
+		const value = await this.connection.get(`${this.config.name}:${sessionId}`);
+		if (!value) return null;
+		return JSON.parse(value);
+	}
+	async write(sessionId, data) {
+		await this.connection.set(`${this.config.name}:${sessionId}`, JSON.stringify(data), "EX", this.config.ttlSec);
+	}
+	async destroy(sessionId) {
+		await this.connection.del(`${this.config.name}:${sessionId}`);
+	}
+	async touch(sessionId) {
+		await this.connection.expire(`${this.config.name}:${sessionId}`, this.config.ttlSec);
+	}
+};
+var MemorySessionStore = class {
+	config;
+	sessions = /* @__PURE__ */ new Map();
+	sweepIntervalMs;
+	ttlMs;
+	lastSweepAt = Date.now();
+	constructor(config, sweepIntervalSec = config.ttlSec) {
+		this.config = config;
+		this.sweepIntervalMs = sweepIntervalSec * 1e3;
+		this.ttlMs = config.ttlSec * 1e3;
+	}
+	read(sessionId) {
+		this.maybeSweep();
+		return this.sessions.get(sessionId)?.data || null;
+	}
+	write(sessionId, data) {
+		this.maybeSweep();
+		this.sessions.set(sessionId, {
+			data,
+			touched: Date.now()
+		});
+	}
+	destroy(sessionId) {
+		this.maybeSweep();
+		this.sessions.delete(sessionId);
+	}
+	touch(sessionId) {
+		this.maybeSweep();
+		const entry = this.sessions.get(sessionId);
+		if (entry) entry.touched = Date.now();
+	}
+	maybeSweep(now = Date.now()) {
+		if (now - this.lastSweepAt < this.sweepIntervalMs) return;
+		this.lastSweepAt = now;
+		for (const [sessionId, entry] of this.sessions) if (now - entry.touched > this.ttlMs) this.sessions.delete(sessionId);
+	}
+};
+
+//#endregion
+export { MemorySessionStore, RedisSessionStore, Session, createSessionModule, defineConfig };

package/dist/types-Cn69QrjS.d.mts

@@ -0,0 +1,11 @@
+//#region src/types.d.ts
+type Promisable<T> = T | Promise<T>;
+type JSONPrimitive = string | number | boolean | null;
+interface JSONObject {
+  [key: string]: JSONValue;
+}
+type JSONArray = JSONValue[];
+type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+type DeepReadonly<T> = T extends Array<infer R> ? ReadonlyArray<DeepReadonly<R>> : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : Readonly<T>;
+//#endregion
+export { JSONValue as a, JSONPrimitive as i, JSONArray as n, Promisable as o, JSONObject as r, DeepReadonly as t };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { a as JSONValue, i as JSONPrimitive, n as JSONArray, o as Promisable, r as JSONObject, t as DeepReadonly } from "./types-Cn69QrjS.mjs";
+export { DeepReadonly, JSONArray, JSONObject, JSONPrimitive, JSONValue, Promisable };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/ultra.d.mts

@@ -0,0 +1,69 @@
+import { n as DefaultSocketData, t as BaseContext } from "./context-ChCsZh7S.mjs";
+import { o as Promisable } from "./types-Cn69QrjS.mjs";
+import { n as BunRoutes } from "./http-BqWCMASL.mjs";
+import { c as StandardSchemaV1 } from "./validation-CkRfxQJ_.mjs";
+import { a as ProcedureHandler, i as Procedure, t as Middleware } from "./middleware-COKreBGP.mjs";
+import { n as Payload } from "./rpc-Ch2UXReT.mjs";
+import { BunRequest, ErrorLike, Server, ServerWebSocket } from "bun";
+
+//#region src/ultra.d.ts
+interface ProceduresMap {
+  [key: string]: Procedure<any, any, any> | ProceduresMap;
+}
+interface ServerEventMap<SocketData extends DefaultSocketData = DefaultSocketData> {
+  'error': [ErrorLike];
+  'unhandled:error': [ErrorLike];
+  'http:request': [BunRequest, Server<SocketData>];
+  'ws:open': [ServerWebSocket<SocketData>];
+  'ws:message': [ServerWebSocket<SocketData>, string | Buffer<ArrayBuffer>];
+  'ws:close': [ServerWebSocket<SocketData>, number, string];
+  'server:started': [Server<SocketData>];
+  'server:stopped': [Server<SocketData>, closeActiveConnections: boolean];
+}
+type ServerEventListener<K extends keyof ServerEventMap> = (...args: ServerEventMap[K]) => any;
+type DeriveFunction<C extends BaseContext> = (context: C) => Promisable<Record<PropertyKey, any>>;
+type DeriveValue<C extends BaseContext> = DeriveFunction<C> | Record<PropertyKey, any>;
+type ExtractDerive<C extends BaseContext, T extends DeriveValue<C>> = T extends DeriveFunction<C> ? Awaited<ReturnType<T>> : T;
+type StartOptions<SocketData extends DefaultSocketData> = Omit<Partial<Bun.Serve.Options<SocketData>>, 'websocket' | 'error' | 'routes'>;
+interface UltraOptions {
+  http: boolean;
+}
+type InputFactory<C extends BaseContext> = <I>(schema?: StandardSchemaV1<I>) => Procedure<I, unknown, C>;
+type ProcedureMapInitializer<R extends ProceduresMap, C extends BaseContext = BaseContext> = (input: InputFactory<C>) => R;
+declare class Ultra<Procedures extends ProceduresMap = ProceduresMap, Context extends BaseContext = BaseContext, SocketData extends DefaultSocketData = DefaultSocketData> {
+  protected readonly initializers: Set<ProcedureMapInitializer<any, Context>>;
+  protected readonly handlers: Map<string, ProcedureHandler<any, any, Context>>;
+  protected readonly events: Map<keyof ServerEventMap<SocketData>, Set<ServerEventListener<any>>>;
+  protected readonly middlewares: Set<Middleware<any, any, Context>>;
+  protected readonly derived: Set<DeriveValue<Context>>;
+  protected readonly derivedWS: Set<DeriveValue<Context>>;
+  protected readonly options: UltraOptions;
+  protected server?: Server<SocketData>;
+  constructor(options?: Partial<UltraOptions>);
+  /** Register procedures */
+  routes<const P extends ProceduresMap>(initializer: ProcedureMapInitializer<P, Context>): Ultra<Procedures & P, Context, SocketData>;
+  /** Register middleware or another Ultra instance */
+  use<const PluginProcedures extends ProceduresMap, const PluginContext extends BaseContext, const PluginSocketData extends DefaultSocketData>(entity: Middleware<unknown, unknown, Context> | Ultra<PluginProcedures, PluginContext, PluginSocketData>): Ultra<Procedures & PluginProcedures, Context & PluginContext, SocketData & PluginSocketData>;
+  /** Extends  context values for every request with provided values */
+  derive<const D extends DeriveValue<Context>>(derive: D): Ultra<Procedures, Context & ExtractDerive<Context, D>, SocketData>;
+  /** Extends WS data for every ws connection */
+  deriveWS<const D extends DeriveValue<Context>>(derive: D): Ultra<Procedures, Context, SocketData & ExtractDerive<Context, D>>;
+  start(options?: StartOptions<SocketData>): Server<SocketData>;
+  stop(closeActiveConnections?: boolean): Promise<void>;
+  on<E extends keyof ServerEventMap>(event: E, listener: ServerEventListener<E>): this;
+  off<E extends keyof ServerEventMap>(event: E, listener: ServerEventListener<E>): this;
+  emit<E extends keyof ServerEventMap>(event: E, ...args: ServerEventMap[E]): this;
+  protected handleRPC(ws: ServerWebSocket<SocketData>, payload: Payload): Promise<void>;
+  /** Enrich context with derived values */
+  protected enrichContext(context: BaseContext): Promise<Context>;
+  /** Merge other Ultra instance with deduplication */
+  protected merge(module: Ultra<any, any, any>): void;
+  /** Wrap procedure handler with global middlewares */
+  protected wrapHandler(handler: ProcedureHandler<any, any, any>): ProcedureHandler<any, any, any>;
+  /** Build flat map from procedures tree and write handles map */
+  protected buildProcedures(): Map<string, Procedure<any, any, Context>>;
+  /** Build Bun native HTTP routes */
+  protected buildRoutes(procedures: Map<string, Procedure<any, any, Context>>): BunRoutes;
+}
+//#endregion
+export { ProceduresMap, Ultra };

package/dist/ultra.mjs

@@ -0,0 +1,273 @@
+import { t as Procedure } from "./procedure-BN1rLLRX.mjs";
+import { n as toRPCResponse, t as toHTTPResponse } from "./response-CNhIkAYG.mjs";
+import { t as isRPC } from "./rpc-_rBI0z-9.mjs";
+import { serve } from "bun";
+
+//#region src/ultra.ts
+var Ultra = class {
+	initializers = /* @__PURE__ */ new Set();
+	handlers = /* @__PURE__ */ new Map();
+	events = /* @__PURE__ */ new Map();
+	middlewares = /* @__PURE__ */ new Set();
+	derived = /* @__PURE__ */ new Set();
+	derivedWS = /* @__PURE__ */ new Set();
+	options = { http: true };
+	server;
+	constructor(options) {
+		Object.assign(this.options, options);
+	}
+	/** Register procedures */
+	routes(initializer) {
+		this.initializers.add(initializer);
+		return this;
+	}
+	/** Register middleware or another Ultra instance */
+	use(entity) {
+		if (typeof entity === "function") {
+			this.middlewares.add(entity);
+			return this;
+		}
+		this.merge(entity);
+		return this;
+	}
+	/** Extends  context values for every request with provided values */
+	derive(derive) {
+		this.derived.add(derive);
+		return this;
+	}
+	/** Extends WS data for every ws connection */
+	deriveWS(derive) {
+		this.derivedWS.add(derive);
+		return this;
+	}
+	start(options) {
+		if (this.server) {
+			console.warn("Server is already running");
+			return this.server;
+		}
+		const procedures = this.buildProcedures();
+		const notFoundHandler = this.wrapHandler(() => new Response("Not Found", { status: 404 }));
+		this.server = serve({
+			...options ?? {},
+			routes: {
+				...this.options.http && {
+					...this.buildRoutes(procedures),
+					"/*": async (request, server) => {
+						this.emit("http:request", request, server);
+						return notFoundHandler({
+							input: null,
+							context: this.derived.size ? await this.enrichContext({
+								server,
+								request
+							}) : {
+								server,
+								request
+							}
+						});
+					}
+				},
+				"/ws": async (request, server) => {
+					if (this.derivedWS.size) {
+						const data = {};
+						const context = this.derived.size ? await this.enrichContext({
+							server,
+							request
+						}) : {
+							server,
+							request
+						};
+						for (const derive of this.derivedWS) Object.assign(data, typeof derive === "function" ? await derive(context) : derive);
+						server.upgrade(request, { data });
+						return;
+					}
+					server.upgrade(request);
+				}
+			},
+			websocket: {
+				open: (ws) => {
+					this.emit("ws:open", ws);
+				},
+				close: (ws, code, reason) => {
+					this.emit("ws:close", ws, code, reason);
+				},
+				message: (ws, message) => {
+					this.emit("ws:message", ws, message);
+					if (typeof message !== "string") return;
+					const data = JSON.parse(message);
+					if (isRPC(data)) this.handleRPC(ws, data);
+				}
+			},
+			error: (error) => {
+				this.emit("unhandled:error", error);
+				console.error("Unhandled server error:", error);
+				return new Response("Internal Server Error", { status: 500 });
+			}
+		});
+		this.emit("server:started", this.server);
+		return this.server;
+	}
+	async stop(closeActiveConnections = false) {
+		if (!this.server) return console.error("Server is not running");
+		await this.server.stop(closeActiveConnections);
+		this.emit("server:stopped", this.server, closeActiveConnections);
+	}
+	on(event, listener) {
+		if (!this.events.has(event)) this.events.set(event, /* @__PURE__ */ new Set());
+		this.events.get(event).add(listener);
+		return this;
+	}
+	off(event, listener) {
+		this.events.get(event)?.delete(listener);
+		return this;
+	}
+	emit(event, ...args) {
+		this.events.get(event)?.forEach((listener) => listener(...args));
+		return this;
+	}
+	async handleRPC(ws, payload) {
+		const handler = this.handlers.get(payload.method);
+		if (!handler) {
+			ws.send(`{"id": "${payload.id}", "error": {"code": 404, "message": "Not found"}}`);
+			return;
+		}
+		try {
+			ws.send(toRPCResponse(payload.id, await handler({
+				input: payload.params,
+				context: await this.enrichContext({
+					server: this.server,
+					ws
+				})
+			})));
+		} catch (error) {
+			this.emit("error", error);
+			ws.send(toRPCResponse(payload.id, error));
+		}
+	}
+	/** Enrich context with derived values */
+	async enrichContext(context) {
+		for (const derive of this.derived) Object.assign(context, typeof derive === "function" ? await derive(context) : derive);
+		return context;
+	}
+	/** Merge other Ultra instance with deduplication */
+	merge(module) {
+		module.initializers.forEach((init) => this.initializers.add(init));
+		module.derived.forEach((derive) => this.derived.add(derive));
+		module.derivedWS.forEach((derive) => this.derivedWS.add(derive));
+		module.middlewares.forEach((mw) => this.middlewares.add(mw));
+		module.events.forEach((listeners, event) => {
+			if (!this.events.has(event)) this.events.set(event, /* @__PURE__ */ new Set());
+			const targetListeners = this.events.get(event);
+			listeners.forEach((listener) => targetListeners.add(listener));
+		});
+	}
+	/** Wrap procedure handler with global middlewares */
+	wrapHandler(handler) {
+		if (!this.middlewares.size) return handler;
+		const middlewares = Array.from(this.middlewares);
+		return async (options) => {
+			let idx = 0;
+			const next = () => {
+				if (idx === middlewares.length) return handler(options);
+				return middlewares[idx++]({
+					...options,
+					next
+				});
+			};
+			return next();
+		};
+	}
+	/** Build flat map from procedures tree and write handles map */
+	buildProcedures() {
+		const procedures = /* @__PURE__ */ new Map();
+		const inputFactory = (schema) => {
+			const procedure = new Procedure();
+			return schema ? procedure.input(schema) : procedure;
+		};
+		for (const initializer of this.initializers) {
+			const map = initializer(inputFactory);
+			const stack = [];
+			for (const [key, value] of Object.entries(map)) stack.push({
+				path: key,
+				value
+			});
+			while (stack.length) {
+				const { path, value } = stack.pop();
+				if (value instanceof Procedure) {
+					if (procedures.has(path)) throw new Error(`Procedure conflict at path "${path}"`);
+					procedures.set(path, value);
+					this.handlers.set(path, this.wrapHandler(value.wrap()));
+					continue;
+				}
+				for (const [childKey, childValue] of Object.entries(value)) {
+					const nextPath = path ? `${path}/${childKey}` : childKey;
+					stack.push({
+						path: nextPath,
+						value: childValue
+					});
+				}
+			}
+		}
+		return procedures;
+	}
+	/** Build Bun native HTTP routes */
+	buildRoutes(procedures) {
+		const routes = {};
+		for (const [path, procedure] of procedures) {
+			const procedureInfo = procedure.getInfo();
+			if (!procedureInfo.http?.enabled) continue;
+			const httpPath = `/${path}`;
+			const handler = this.handlers.get(path);
+			if (!handler) throw new Error(`Handler for procedure at path "${path}" is not defined`);
+			const httpHandler = async (request, server) => {
+				this.emit("http:request", request, server);
+				let input = request.body;
+				const baseContext = {
+					server,
+					request
+				};
+				const context = this.derived.size ? await this.enrichContext(baseContext) : baseContext;
+				if (input && procedureInfo.hasInput) {
+					if (request.method === "GET") {
+						const query = request.url.indexOf("?");
+						if (query !== -1 && query < request.url.length - 1) input = Object.fromEntries(new URLSearchParams(request.url.slice(query + 1)).entries());
+					} else if (request.headers.get("Content-Length") !== "0") {
+						const type = request.headers.get("Content-Type");
+						if (type) switch (true) {
+							case type.startsWith("application/json"):
+								input = await request.json();
+								break;
+							case type.startsWith("text"):
+								input = await request.text();
+								break;
+							case type.startsWith("multipart/form-data"):
+								input = await request.formData();
+								break;
+							default:
+								console.error(`Unsupported Content-Type for procedure ${path}: ${type}`);
+								break;
+						}
+					}
+				}
+				try {
+					return toHTTPResponse(await handler({
+						input,
+						context
+					}));
+				} catch (error) {
+					this.emit("error", error);
+					return toHTTPResponse(error);
+				}
+			};
+			if (!procedureInfo.http.method) {
+				routes[httpPath] = httpHandler;
+				continue;
+			}
+			if (!routes[httpPath]) routes[httpPath] = {};
+			routes[httpPath][procedureInfo.http.method] = httpHandler;
+		}
+		return routes;
+	}
+};
+
+//#endregion
+export { Ultra };