@vertz/core 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,270 @@
+import { Schema } from "@vertz/schema";
+interface MiddlewareDef<
+	TRequires extends Record<string, unknown> = Record<string, unknown>,
+	TProvides extends Record<string, unknown> = Record<string, unknown>
+> {
+	inject?: Record<string, unknown>;
+	headers?: Schema<unknown>;
+	params?: Schema<unknown>;
+	query?: Schema<unknown>;
+	body?: Schema<unknown>;
+	requires?: Schema<TRequires>;
+	provides?: Schema<TProvides>;
+	handler: (ctx: Record<string, unknown>) => Promise<TProvides> | TProvides;
+}
+interface NamedMiddlewareDef<
+	TRequires extends Record<string, unknown> = Record<string, unknown>,
+	TProvides extends Record<string, unknown> = Record<string, unknown>
+> extends MiddlewareDef<TRequires, TProvides> {
+	name: string;
+}
+declare function createMiddleware<
+	TRequires extends Record<string, unknown> = Record<string, unknown>,
+	TProvides extends Record<string, unknown> = Record<string, unknown>
+>(def: NamedMiddlewareDef<TRequires, TProvides>): NamedMiddlewareDef<TRequires, TProvides>;
+import { Schema as Schema2 } from "@vertz/schema";
+interface ModuleDef<
+	TImports extends Record<string, unknown> = Record<string, unknown>,
+	TOptions extends Record<string, unknown> = Record<string, unknown>
+> {
+	name: string;
+	imports?: TImports;
+	options?: Schema2<TOptions>;
+}
+interface ServiceDef<
+	TDeps = unknown,
+	TState = unknown,
+	TMethods = unknown
+> {
+	inject?: Record<string, unknown>;
+	onInit?: (deps: TDeps) => Promise<TState> | TState;
+	methods: (deps: TDeps, state: TState) => TMethods;
+	onDestroy?: (deps: TDeps, state: TState) => Promise<void> | void;
+}
+interface RouterDef {
+	prefix: string;
+	inject?: Record<string, unknown>;
+}
+interface Module<TDef extends ModuleDef = ModuleDef> {
+	definition: TDef;
+	services: ServiceDef[];
+	routers: RouterDef[];
+	exports: ServiceDef[];
+}
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type BuiltinObject = Date | RegExp | Error | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown> | Request | Response | Headers | ReadableStream | WritableStream;
+type DeepReadonly<T> = unknown extends T ? T : T extends Primitive ? T : T extends BuiltinObject ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : { readonly [K in keyof T] : DeepReadonly<T[K]> };
+interface RawRequest {
+	readonly request: Request;
+	readonly method: string;
+	readonly url: string;
+	readonly headers: Headers;
+}
+interface HandlerCtx {
+	params: Record<string, unknown>;
+	body: unknown;
+	query: Record<string, unknown>;
+	headers: Record<string, unknown>;
+	raw: RawRequest;
+	options: Record<string, unknown>;
+	env: Record<string, unknown>;
+	[key: string]: unknown;
+}
+type Deps<T extends Record<string, unknown>> = DeepReadonly<T>;
+type Ctx<T extends Record<string, unknown>> = DeepReadonly<T>;
+type InferOutput<T> = T extends {
+	_output: infer O;
+} ? O : T extends {
+	parse(v: unknown): infer P;
+} ? P : unknown;
+type TypedHandlerCtx<
+	TParams = unknown,
+	TQuery = unknown,
+	THeaders = unknown,
+	TBody = unknown
+> = Omit<HandlerCtx, "params" | "query" | "headers" | "body"> & {
+	params: TParams;
+	query: TQuery;
+	headers: THeaders;
+	body: TBody;
+};
+interface RouteConfig<
+	TParams = unknown,
+	TQuery = unknown,
+	THeaders = unknown,
+	TBody = unknown
+> {
+	params?: TParams;
+	body?: TBody;
+	query?: TQuery;
+	response?: unknown;
+	headers?: THeaders;
+	middlewares?: unknown[];
+	handler: (ctx: TypedHandlerCtx<InferOutput<TParams>, InferOutput<TQuery>, InferOutput<THeaders>, InferOutput<TBody>>) => unknown;
+}
+interface Route {
+	method: string;
+	path: string;
+	config: RouteConfig<unknown, unknown, unknown, unknown>;
+}
+type HttpMethodFn = <
+	TParams,
+	TQuery,
+	THeaders,
+	TBody
+>(path: `/${string}`, config: RouteConfig<TParams, TQuery, THeaders, TBody>) => NamedRouterDef;
+interface NamedRouterDef extends RouterDef {
+	moduleName: string;
+	routes: Route[];
+	get: HttpMethodFn;
+	post: HttpMethodFn;
+	put: HttpMethodFn;
+	patch: HttpMethodFn;
+	delete: HttpMethodFn;
+	head: HttpMethodFn;
+}
+interface NamedServiceDef<
+	TDeps = unknown,
+	TState = unknown,
+	TMethods = unknown
+> extends ServiceDef<TDeps, TState, TMethods> {
+	moduleName: string;
+}
+interface NamedModuleDef<
+	TImports extends Record<string, unknown> = Record<string, unknown>,
+	TOptions extends Record<string, unknown> = Record<string, unknown>
+> extends ModuleDef<TImports, TOptions> {
+	service: <
+		TDeps,
+		TState,
+		TMethods
+	>(config: ServiceDef<TDeps, TState, TMethods>) => NamedServiceDef<TDeps, TState, TMethods>;
+	router: (config: RouterDef) => NamedRouterDef;
+}
+declare function createModuleDef<
+	TImports extends Record<string, unknown> = Record<string, unknown>,
+	TOptions extends Record<string, unknown> = Record<string, unknown>
+>(config: ModuleDef<TImports, TOptions>): NamedModuleDef<TImports, TOptions>;
+interface NamedModule {
+	definition: NamedModuleDef;
+	services: NamedServiceDef[];
+	routers: NamedRouterDef[];
+	exports: NamedServiceDef[];
+}
+declare function createModule(definition: NamedModuleDef, config: {
+	services: NamedServiceDef[];
+	routers: NamedRouterDef[];
+	exports: NamedServiceDef[];
+}): NamedModule;
+interface CorsConfig {
+	origins?: string | string[] | boolean;
+	methods?: string[];
+	headers?: string[];
+	credentials?: boolean;
+	maxAge?: number;
+	exposedHeaders?: string[];
+}
+interface AppConfig {
+	basePath?: string;
+	version?: string;
+	cors?: CorsConfig;
+}
+interface ListenOptions {
+	hostname?: string;
+}
+interface ServerHandle {
+	readonly port: number;
+	readonly hostname: string;
+	close(): Promise<void>;
+}
+interface ServerAdapter {
+	listen(port: number, handler: (request: Request) => Promise<Response>, options?: ListenOptions): Promise<ServerHandle>;
+}
+interface AppBuilder {
+	register(module: NamedModule, options?: Record<string, unknown>): AppBuilder;
+	middlewares(list: NamedMiddlewareDef[]): AppBuilder;
+	readonly handler: (request: Request) => Promise<Response>;
+	listen(port?: number, options?: ListenOptions): Promise<ServerHandle>;
+}
+declare function createApp(config: AppConfig): AppBuilder;
+import { Schema as Schema3 } from "@vertz/schema";
+interface EnvConfig<T = unknown> {
+	load?: string[];
+	schema: Schema3<T>;
+}
+declare function createEnv<T>(config: EnvConfig<T>): T;
+declare class VertzException extends Error {
+	readonly statusCode: number;
+	readonly code: string;
+	readonly details?: unknown;
+	constructor(message: string, statusCode?: number, code?: string, details?: unknown);
+	toJSON(): Record<string, unknown>;
+}
+declare class BadRequestException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class UnauthorizedException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class ForbiddenException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class NotFoundException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class ConflictException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class ValidationException extends VertzException {
+	readonly errors: ReadonlyArray<{
+		path: string;
+		message: string;
+	}>;
+	constructor(errors: Array<{
+		path: string;
+		message: string;
+	}>);
+	toJSON(): Record<string, unknown>;
+}
+declare class InternalServerErrorException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare class ServiceUnavailableException extends VertzException {
+	constructor(message: string, details?: unknown);
+}
+declare function createImmutableProxy<T extends object>(obj: T, contextName: string, rootName?: string, proxyCache?: WeakMap<object, unknown>): T;
+declare function deepFreeze<T>(obj: T, visited?: WeakSet<object>): T;
+declare function makeImmutable<T extends object>(obj: T, contextName: string): DeepReadonly<T>;
+type ServiceFactory<
+	TDeps = unknown,
+	TState = unknown,
+	TMethods = unknown
+> = ServiceDef<TDeps, TState, TMethods>;
+interface ServiceBootInstruction {
+	type: "service";
+	id: string;
+	deps: string[];
+	factory: ServiceFactory;
+}
+interface ModuleBootInstruction {
+	type: "module";
+	id: string;
+	services: string[];
+	options?: Record<string, unknown>;
+}
+type BootInstruction = ServiceBootInstruction | ModuleBootInstruction;
+interface BootSequence {
+	instructions: BootInstruction[];
+	shutdownOrder: string[];
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type HttpStatusCode = 200 | 201 | 204 | 301 | 302 | 304 | 400 | 401 | 403 | 404 | 405 | 409 | 422 | 429 | 500 | 502 | 503 | 504;
+import { Infer, Infer as Infer2 } from "@vertz/schema";
+declare const vertz: {
+	readonly env: typeof createEnv;
+	readonly middleware: typeof createMiddleware;
+	readonly moduleDef: typeof createModuleDef;
+	readonly module: typeof createModule;
+	readonly app: typeof createApp;
+};
+export { vertz, makeImmutable, deepFreeze, createModuleDef, createModule, createMiddleware, createImmutableProxy, createEnv, createApp, VertzException, ValidationException, UnauthorizedException, ServiceUnavailableException, ServiceFactory, ServiceDef, ServiceBootInstruction, ServerHandle, ServerAdapter, RouterDef, RawRequest, NotFoundException, NamedServiceDef, NamedRouterDef, NamedModuleDef, NamedModule, NamedMiddlewareDef, ModuleDef, ModuleBootInstruction, Module, MiddlewareDef, ListenOptions, InternalServerErrorException, Infer2 as InferSchema, Infer, HttpStatusCode, HttpMethod, HandlerCtx, ForbiddenException, EnvConfig, Deps, DeepReadonly, Ctx, CorsConfig, ConflictException, BootSequence, BootInstruction, BadRequestException, AppConfig, AppBuilder };

package/dist/index.js

@@ -0,0 +1,365 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  InternalServerErrorException,
+  NotFoundException,
+  ServiceUnavailableException,
+  Trie,
+  UnauthorizedException,
+  ValidationException,
+  VertzException,
+  buildCtx,
+  createErrorResponse,
+  createImmutableProxy,
+  createJsonResponse,
+  deepFreeze,
+  makeImmutable,
+  parseBody,
+  parseRequest,
+  runMiddlewareChain
+} from "./shared/chunk-c77pg5gx.js";
+
+// src/server/cors.ts
+var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var DEFAULT_HEADERS = ["Content-Type", "Authorization"];
+function resolveOrigin(config, requestOrigin) {
+  if (config.origins === true || config.origins === "*")
+    return "*";
+  if (!requestOrigin)
+    return null;
+  if (Array.isArray(config.origins)) {
+    return config.origins.includes(requestOrigin) ? requestOrigin : null;
+  }
+  if (typeof config.origins === "string") {
+    return config.origins === requestOrigin ? requestOrigin : null;
+  }
+  return null;
+}
+function handleCors(config, request) {
+  const requestOrigin = request.headers.get("origin");
+  const origin = resolveOrigin(config, requestOrigin);
+  if (request.method === "OPTIONS") {
+    const headers = {};
+    if (origin)
+      headers["access-control-allow-origin"] = origin;
+    const methods = config.methods ?? DEFAULT_METHODS;
+    headers["access-control-allow-methods"] = methods.join(", ");
+    const allowHeaders = config.headers ?? DEFAULT_HEADERS;
+    headers["access-control-allow-headers"] = allowHeaders.join(", ");
+    if (config.maxAge !== undefined) {
+      headers["access-control-max-age"] = String(config.maxAge);
+    }
+    if (config.credentials) {
+      headers["access-control-allow-credentials"] = "true";
+    }
+    return new Response(null, { status: 204, headers });
+  }
+  return null;
+}
+function applyCorsHeaders(config, request, response) {
+  const requestOrigin = request.headers.get("origin");
+  const origin = resolveOrigin(config, requestOrigin);
+  if (!origin)
+    return response;
+  const headers = new Headers(response.headers);
+  headers.set("access-control-allow-origin", origin);
+  if (config.credentials) {
+    headers.set("access-control-allow-credentials", "true");
+  }
+  if (config.exposedHeaders?.length) {
+    headers.set("access-control-expose-headers", config.exposedHeaders.join(", "));
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+
+// src/app/app-runner.ts
+function validateSchema(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof BadRequestException)
+      throw error;
+    const message = error instanceof Error ? error.message : `Invalid ${label}`;
+    throw new BadRequestException(message);
+  }
+}
+function resolveServices(registrations) {
+  const serviceMap = new Map;
+  for (const { module } of registrations) {
+    for (const service of module.services) {
+      if (!serviceMap.has(service)) {
+        serviceMap.set(service, service.methods({}, undefined));
+      }
+    }
+  }
+  return serviceMap;
+}
+function resolveMiddlewares(globalMiddlewares) {
+  return globalMiddlewares.map((mw) => ({
+    name: mw.name,
+    handler: mw.handler,
+    resolvedInject: {}
+  }));
+}
+function resolveRouterServices(inject, serviceMap) {
+  if (!inject)
+    return {};
+  const resolved = {};
+  for (const [name, serviceDef] of Object.entries(inject)) {
+    const methods = serviceMap.get(serviceDef);
+    if (methods)
+      resolved[name] = methods;
+  }
+  return resolved;
+}
+function registerRoutes(trie, basePath, registrations, serviceMap) {
+  for (const { module, options } of registrations) {
+    for (const router of module.routers) {
+      const resolvedServices = resolveRouterServices(router.inject, serviceMap);
+      for (const route of router.routes) {
+        const fullPath = basePath + router.prefix + route.path;
+        const entry = {
+          handler: route.config.handler,
+          options: options ?? {},
+          services: resolvedServices,
+          paramsSchema: route.config.params,
+          bodySchema: route.config.body,
+          querySchema: route.config.query,
+          headersSchema: route.config.headers
+        };
+        trie.add(route.method, fullPath, entry);
+      }
+    }
+  }
+}
+function buildHandler(config, registrations, globalMiddlewares) {
+  const trie = new Trie;
+  const basePath = config.basePath ?? "";
+  const resolvedMiddlewares = resolveMiddlewares(globalMiddlewares);
+  const serviceMap = resolveServices(registrations);
+  registerRoutes(trie, basePath, registrations, serviceMap);
+  return async (request) => {
+    try {
+      if (config.cors) {
+        const corsResponse = handleCors(config.cors, request);
+        if (corsResponse)
+          return corsResponse;
+      }
+      const parsed = parseRequest(request);
+      const match = trie.match(parsed.method, parsed.path);
+      if (!match) {
+        const allowed = trie.getAllowedMethods(parsed.path);
+        if (allowed.length > 0) {
+          return createJsonResponse({ error: "MethodNotAllowed", message: "Method Not Allowed", statusCode: 405 }, 405, { allow: allowed.join(", ") });
+        }
+        return createJsonResponse({ error: "NotFound", message: "Not Found", statusCode: 404 }, 404);
+      }
+      const body = await parseBody(request);
+      const raw = {
+        request: parsed.raw,
+        method: parsed.method,
+        url: parsed.raw.url,
+        headers: parsed.raw.headers
+      };
+      const requestCtx = {
+        params: match.params,
+        body,
+        query: parsed.query,
+        headers: parsed.headers,
+        raw
+      };
+      const middlewareState = await runMiddlewareChain(resolvedMiddlewares, requestCtx);
+      const entry = match.handler;
+      const validatedParams = entry.paramsSchema ? validateSchema(entry.paramsSchema, match.params, "params") : match.params;
+      const validatedBody = entry.bodySchema ? validateSchema(entry.bodySchema, body, "body") : body;
+      const validatedQuery = entry.querySchema ? validateSchema(entry.querySchema, parsed.query, "query") : parsed.query;
+      const validatedHeaders = entry.headersSchema ? validateSchema(entry.headersSchema, parsed.headers, "headers") : parsed.headers;
+      const ctx = buildCtx({
+        params: validatedParams,
+        body: validatedBody,
+        query: validatedQuery,
+        headers: validatedHeaders,
+        raw,
+        middlewareState,
+        services: entry.services,
+        options: entry.options,
+        env: {}
+      });
+      const result = await entry.handler(ctx);
+      const response = result === undefined ? new Response(null, { status: 204 }) : createJsonResponse(result);
+      if (config.cors) {
+        return applyCorsHeaders(config.cors, request, response);
+      }
+      return response;
+    } catch (error) {
+      return createErrorResponse(error);
+    }
+  };
+}
+
+// src/app/bun-adapter.ts
+function createBunAdapter() {
+  return {
+    async listen(port, handler, options) {
+      const server = Bun.serve({
+        port,
+        hostname: options?.hostname,
+        fetch: handler
+      });
+      return {
+        port: server.port,
+        hostname: server.hostname,
+        async close() {
+          server.stop(true);
+        }
+      };
+    }
+  };
+}
+
+// src/app/detect-adapter.ts
+function detectRuntime() {
+  return { hasBun: "Bun" in globalThis };
+}
+function detectAdapter(hints) {
+  const runtime = hints ?? detectRuntime();
+  if (runtime.hasBun) {
+    return createBunAdapter();
+  }
+  throw new Error("No supported server runtime detected. Vertz requires Bun to use app.listen().");
+}
+
+// src/app/app-builder.ts
+var DEFAULT_PORT = 3000;
+function createApp(config) {
+  const registrations = [];
+  let globalMiddlewares = [];
+  let cachedHandler = null;
+  const builder = {
+    register(module, options) {
+      registrations.push({ module, options });
+      return builder;
+    },
+    middlewares(list) {
+      globalMiddlewares = list;
+      return builder;
+    },
+    get handler() {
+      if (!cachedHandler) {
+        cachedHandler = buildHandler(config, registrations, globalMiddlewares);
+      }
+      return cachedHandler;
+    },
+    async listen(port, options) {
+      const adapter = detectAdapter();
+      return adapter.listen(port ?? DEFAULT_PORT, builder.handler, options);
+    }
+  };
+  return builder;
+}
+// src/env/env-validator.ts
+function createEnv(config) {
+  const result = config.schema.safeParse(process.env);
+  if (!result.success) {
+    throw new Error(`Environment validation failed:
+${result.error.message}`);
+  }
+  return deepFreeze(result.data);
+}
+// src/middleware/middleware-def.ts
+function createMiddleware(def) {
+  return deepFreeze(def);
+}
+// src/module/module.ts
+function validateOwnership(items, kind, expectedModule) {
+  for (const item of items) {
+    if (item.moduleName !== expectedModule) {
+      throw new Error(`${kind} belongs to module "${item.moduleName}", cannot add to module "${expectedModule}"`);
+    }
+  }
+}
+function createModule(definition, config) {
+  validateOwnership(config.services, "Service", definition.name);
+  validateOwnership(config.routers, "Router", definition.name);
+  for (const exp of config.exports) {
+    if (!config.services.includes(exp)) {
+      throw new Error("exports must be a subset of services");
+    }
+  }
+  return deepFreeze({
+    definition,
+    ...config
+  });
+}
+// src/module/router-def.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head"];
+function createRouterDef(moduleName, config) {
+  const routes = [];
+  function addRoute(method, path, routeConfig) {
+    if (!path.startsWith("/")) {
+      throw new Error(`Route path must start with '/', got '${path}'`);
+    }
+    routes.push({ method, path, config: routeConfig });
+    return router;
+  }
+  const router = {
+    ...config,
+    moduleName,
+    routes
+  };
+  for (const method of HTTP_METHODS) {
+    router[method] = (path, cfg) => addRoute(method.toUpperCase(), path, cfg);
+  }
+  return router;
+}
+
+// src/module/service.ts
+function createServiceDef(moduleName, config) {
+  return deepFreeze({
+    ...config,
+    moduleName
+  });
+}
+
+// src/module/module-def.ts
+function createModuleDef(config) {
+  const def = {
+    ...config,
+    service: (serviceConfig) => createServiceDef(config.name, serviceConfig),
+    router: (routerConfig) => createRouterDef(config.name, routerConfig)
+  };
+  return deepFreeze(def);
+}
+// src/vertz.ts
+var vertz = deepFreeze({
+  env: createEnv,
+  middleware: createMiddleware,
+  moduleDef: createModuleDef,
+  module: createModule,
+  app: createApp
+});
+export {
+  vertz,
+  makeImmutable,
+  deepFreeze,
+  createModuleDef,
+  createModule,
+  createMiddleware,
+  createImmutableProxy,
+  createEnv,
+  createApp,
+  VertzException,
+  ValidationException,
+  UnauthorizedException,
+  ServiceUnavailableException,
+  NotFoundException,
+  InternalServerErrorException,
+  ForbiddenException,
+  ConflictException,
+  BadRequestException
+};

package/dist/internals.d.ts

@@ -0,0 +1,59 @@
+interface RawRequest {
+	readonly request: Request;
+	readonly method: string;
+	readonly url: string;
+	readonly headers: Headers;
+}
+interface HandlerCtx {
+	params: Record<string, unknown>;
+	body: unknown;
+	query: Record<string, unknown>;
+	headers: Record<string, unknown>;
+	raw: RawRequest;
+	options: Record<string, unknown>;
+	env: Record<string, unknown>;
+	[key: string]: unknown;
+}
+interface CtxConfig {
+	params: Record<string, unknown>;
+	body: unknown;
+	query: Record<string, unknown>;
+	headers: Record<string, unknown>;
+	raw: RawRequest;
+	middlewareState: Record<string, unknown>;
+	services: Record<string, unknown>;
+	options: Record<string, unknown>;
+	env: Record<string, unknown>;
+}
+declare function buildCtx(config: CtxConfig): HandlerCtx;
+interface ResolvedMiddleware {
+	name: string;
+	handler: (ctx: Record<string, unknown>) => Promise<unknown> | unknown;
+	resolvedInject: Record<string, unknown>;
+}
+declare function runMiddlewareChain(middlewares: ResolvedMiddleware[], requestCtx: Record<string, unknown>): Promise<Record<string, unknown>>;
+interface MatchResult<T = unknown> {
+	handler: T;
+	params: Record<string, string>;
+}
+declare class Trie<T = unknown> {
+	private root;
+	add(method: string, path: string, handler: T): void;
+	match(method: string, path: string): MatchResult<T> | null;
+	getAllowedMethods(path: string): string[];
+	private resolveChild;
+	private findNode;
+	private matchNode;
+}
+interface ParsedRequest {
+	method: string;
+	path: string;
+	query: Record<string, string>;
+	headers: Record<string, string>;
+	raw: Request;
+}
+declare function parseRequest(request: Request): ParsedRequest;
+declare function parseBody(request: Request): Promise<unknown>;
+declare function createJsonResponse(data: unknown, status?: number, headers?: Record<string, string>): Response;
+declare function createErrorResponse(error: unknown): Response;
+export { runMiddlewareChain, parseRequest, parseBody, createJsonResponse, createErrorResponse, buildCtx, Trie, ResolvedMiddleware };

package/dist/internals.js

@@ -0,0 +1,18 @@
+import {
+  Trie,
+  buildCtx,
+  createErrorResponse,
+  createJsonResponse,
+  parseBody,
+  parseRequest,
+  runMiddlewareChain
+} from "./shared/chunk-c77pg5gx.js";
+export {
+  runMiddlewareChain,
+  parseRequest,
+  parseBody,
+  createJsonResponse,
+  createErrorResponse,
+  buildCtx,
+  Trie
+};

package/dist/shared/chunk-c77pg5gx.js

@@ -0,0 +1,340 @@
+// src/immutability/dev-proxy.ts
+function createImmutableProxy(obj, contextName, rootName, proxyCache = new WeakMap) {
+  if (proxyCache.has(obj)) {
+    return proxyCache.get(obj);
+  }
+  const root = rootName ?? contextName;
+  const proxy = new Proxy(obj, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (value !== null && typeof value === "object" && typeof property === "string") {
+        return createImmutableProxy(value, `${contextName}.${property}`, root, proxyCache);
+      }
+      return value;
+    },
+    set(_target, property) {
+      throw new TypeError(`Cannot set property "${String(property)}" on ${contextName}. ${root} is immutable.`);
+    },
+    deleteProperty(_target, property) {
+      throw new TypeError(`Cannot delete property "${String(property)}" on ${contextName}. ${root} is immutable.`);
+    }
+  });
+  proxyCache.set(obj, proxy);
+  return proxy;
+}
+
+// src/immutability/freeze.ts
+function deepFreeze(obj, visited = new WeakSet) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return obj;
+  }
+  visited.add(obj);
+  Object.freeze(obj);
+  for (const value of Object.values(obj)) {
+    deepFreeze(value, visited);
+  }
+  return obj;
+}
+
+// src/immutability/make-immutable.ts
+function makeImmutable(obj, contextName) {
+  if (true) {
+    return createImmutableProxy(obj, contextName);
+  }
+  return obj;
+}
+// src/context/ctx-builder.ts
+var RESERVED_KEYS = ["params", "body", "query", "headers", "raw", "options", "env"];
+function validateCollisions(config) {
+  const middlewareKeys = Object.keys(config.middlewareState);
+  for (const key of middlewareKeys) {
+    if (RESERVED_KEYS.includes(key)) {
+      throw new Error(`Middleware cannot provide reserved ctx key: "${key}"`);
+    }
+  }
+  for (const key of Object.keys(config.services)) {
+    if (RESERVED_KEYS.includes(key)) {
+      throw new Error(`Service name cannot shadow reserved ctx key: "${key}"`);
+    }
+    if (middlewareKeys.includes(key)) {
+      throw new Error(`Service name "${key}" collides with middleware-provided key`);
+    }
+  }
+}
+function buildCtx(config) {
+  if (true) {
+    validateCollisions(config);
+  }
+  return makeImmutable({
+    params: config.params,
+    body: config.body,
+    query: config.query,
+    headers: config.headers,
+    raw: config.raw,
+    options: config.options,
+    env: config.env,
+    ...config.middlewareState,
+    ...config.services
+  }, "ctx");
+}
+
+// src/exceptions/vertz-exception.ts
+class VertzException extends Error {
+  statusCode;
+  code;
+  details;
+  constructor(message, statusCode = 500, code, details) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.code = code ?? this.name;
+    this.details = details;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      error: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      code: this.code,
+      ...this.details !== undefined && { details: this.details }
+    };
+  }
+}
+
+// src/exceptions/http-exceptions.ts
+class BadRequestException extends VertzException {
+  constructor(message, details) {
+    super(message, 400, undefined, details);
+  }
+}
+
+class UnauthorizedException extends VertzException {
+  constructor(message, details) {
+    super(message, 401, undefined, details);
+  }
+}
+
+class ForbiddenException extends VertzException {
+  constructor(message, details) {
+    super(message, 403, undefined, details);
+  }
+}
+
+class NotFoundException extends VertzException {
+  constructor(message, details) {
+    super(message, 404, undefined, details);
+  }
+}
+
+class ConflictException extends VertzException {
+  constructor(message, details) {
+    super(message, 409, undefined, details);
+  }
+}
+
+class ValidationException extends VertzException {
+  errors;
+  constructor(errors) {
+    super("Validation failed", 422, undefined, undefined);
+    this.errors = errors;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      errors: this.errors
+    };
+  }
+}
+
+class InternalServerErrorException extends VertzException {
+  constructor(message, details) {
+    super(message, 500, undefined, details);
+  }
+}
+
+class ServiceUnavailableException extends VertzException {
+  constructor(message, details) {
+    super(message, 503, undefined, details);
+  }
+}
+// src/middleware/middleware-runner.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function runMiddlewareChain(middlewares, requestCtx) {
+  const accumulated = {};
+  for (const mw of middlewares) {
+    const ctx = { ...requestCtx, ...mw.resolvedInject, ...accumulated };
+    const contribution = await mw.handler(ctx);
+    if (isPlainObject(contribution)) {
+      Object.assign(accumulated, contribution);
+    }
+  }
+  return accumulated;
+}
+
+// src/router/trie.ts
+function createNode() {
+  return {
+    staticChildren: new Map,
+    paramChild: null,
+    wildcardChild: null,
+    handlers: new Map
+  };
+}
+function splitPath(path) {
+  return path.split("/").filter(Boolean);
+}
+
+class Trie {
+  root = createNode();
+  add(method, path, handler) {
+    const segments = splitPath(path);
+    let node = this.root;
+    for (const segment of segments) {
+      node = this.resolveChild(node, segment);
+    }
+    node.handlers.set(method, handler);
+  }
+  match(method, path) {
+    const segments = splitPath(path);
+    return this.matchNode(this.root, segments, 0, method, {});
+  }
+  getAllowedMethods(path) {
+    const segments = splitPath(path);
+    const node = this.findNode(this.root, segments, 0);
+    if (!node)
+      return [];
+    return Array.from(node.handlers.keys());
+  }
+  resolveChild(node, segment) {
+    if (segment === "*") {
+      node.wildcardChild ??= createNode();
+      return node.wildcardChild;
+    }
+    if (segment.startsWith(":")) {
+      const name = segment.slice(1);
+      if (!node.paramChild) {
+        node.paramChild = { name, node: createNode() };
+      } else if (node.paramChild.name !== name) {
+        throw new Error(`Param name mismatch: existing ":${node.paramChild.name}" conflicts with ":${name}"`);
+      }
+      return node.paramChild.node;
+    }
+    let child = node.staticChildren.get(segment);
+    if (!child) {
+      child = createNode();
+      node.staticChildren.set(segment, child);
+    }
+    return child;
+  }
+  findNode(node, segments, index) {
+    if (index === segments.length)
+      return node;
+    const segment = segments[index];
+    if (segment === undefined)
+      return null;
+    const staticChild = node.staticChildren.get(segment);
+    if (staticChild) {
+      const result = this.findNode(staticChild, segments, index + 1);
+      if (result)
+        return result;
+    }
+    if (node.paramChild) {
+      const result = this.findNode(node.paramChild.node, segments, index + 1);
+      if (result)
+        return result;
+    }
+    if (node.wildcardChild)
+      return node.wildcardChild;
+    return null;
+  }
+  matchNode(node, segments, index, method, params) {
+    if (index === segments.length) {
+      const handler = node.handlers.get(method);
+      if (!handler)
+        return null;
+      return { handler, params: { ...params } };
+    }
+    const segment = segments[index];
+    if (segment === undefined)
+      return null;
+    const staticChild = node.staticChildren.get(segment);
+    if (staticChild) {
+      const result = this.matchNode(staticChild, segments, index + 1, method, params);
+      if (result)
+        return result;
+    }
+    if (node.paramChild) {
+      const result = this.matchNode(node.paramChild.node, segments, index + 1, method, {
+        ...params,
+        [node.paramChild.name]: segment
+      });
+      if (result)
+        return result;
+    }
+    if (node.wildcardChild) {
+      const handler = node.wildcardChild.handlers.get(method);
+      if (handler) {
+        const rest = segments.slice(index).join("/");
+        return { handler, params: { ...params, "*": rest } };
+      }
+    }
+    return null;
+  }
+}
+
+// src/server/request-utils.ts
+function parseRequest(request) {
+  const url = new URL(request.url);
+  return {
+    method: request.method,
+    path: url.pathname,
+    query: Object.fromEntries(url.searchParams),
+    headers: Object.fromEntries(request.headers),
+    raw: request
+  };
+}
+async function parseBody(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return await request.json();
+    } catch {
+      throw new BadRequestException("Invalid JSON body");
+    }
+  }
+  if (contentType.startsWith("text/")) {
+    return request.text();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text = await request.text();
+    return Object.fromEntries(new URLSearchParams(text));
+  }
+  return;
+}
+
+// src/server/response-utils.ts
+function createJsonResponse(data, status = 200, headers) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    }
+  });
+}
+function createErrorResponse(error) {
+  if (error instanceof VertzException) {
+    return createJsonResponse(error.toJSON(), error.statusCode);
+  }
+  return createJsonResponse({ error: "InternalServerError", message: "Internal Server Error", statusCode: 500 }, 500);
+}
+
+export { createImmutableProxy, deepFreeze, makeImmutable, buildCtx, VertzException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, ConflictException, ValidationException, InternalServerErrorException, ServiceUnavailableException, runMiddlewareChain, Trie, parseRequest, parseBody, createJsonResponse, createErrorResponse };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@vertz/core",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./internals": {
+      "import": "./dist/internals.js",
+      "types": "./dist/internals.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bunup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@vertz/schema": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "bunup": "latest",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}