dynara 0.0.1

package/README.md

@@ -0,0 +1,150 @@
+# Marci
+
+[![NPM version](https://img.shields.io/npm/v/%40den59k%2Fmarci)](https://www.npmjs.com/package/@den59k/marci)
+
+An extremely simple HTTP framework for Bun — practically a typed wrapper around `Bun.serve`, with Fastify-style routing and fast schema validation. Made for people switching over from Fastify.
+
+- **Bun only** — Node.js and Deno are not supported.
+- **Minimal overhead** — routing is delegated to Bun's native router.
+- **Typed validation** — powered by [TypeBox](https://www.npmjs.com/package/@sinclair/typebox), written with the compact [compact-json-schema](https://www.npmjs.com/package/compact-json-schema) syntax.
+
+## Install
+
+```sh
+bun add @den59k/marci
+```
+
+## Quick start
+
+```ts
+import { MarciApp } from '@den59k/marci'
+
+const app = new MarciApp()
+
+app.get('/', () => {
+  return { hello: 'world' }
+})
+
+app.listen(3000)
+```
+
+A handler may return a plain value (sent as JSON), a `Response` (sent as-is), or `undefined` (an empty `200`).
+
+## Routes & validation
+
+Routes use Bun's native patterns — `:param` for a single segment, `*` for a wildcard. The methods are `get`, `post`, `put`, `patch`, and `delete`.
+
+Schemas are written with [compact-json-schema](https://www.npmjs.com/package/compact-json-schema) and validated with TypeBox. Pass them as a route-option object, or as a positional array — `[params]` / `[params, query]` for `GET`, `[params, body, query]` for the others. Validated `req.params`, `req.query`, and `req.body` are fully typed.
+
+```ts
+import { schema } from 'compact-json-schema'
+
+const params = schema({ id: 'number' })
+const body = schema({ name: 'string', age: 'number?' }) // ? optional, ?? nullable
+
+// Option object
+app.post('/users/:id', { params, body }, (req) => {
+  req.params.id   // number
+  req.body.name   // string
+  return { ok: true }
+})
+
+// Positional array
+app.get('/users/:id', [params], (req) => {
+  return { id: req.params.id } // number
+})
+```
+
+A few conveniences:
+
+- **Array params** are comma-split: `GET /items/1,2,3` with `{ itemIds: { type: 'array', items: 'number' } }` yields `[1, 2, 3]`.
+- **Query booleans** accept `?flag=true` or a bare `?flag`.
+- `req.raw` exposes the underlying `BunRequest`, and `req.server` the Bun `Server`.
+
+## Hooks
+
+```ts
+app.addHook('onRequest', (req) => {
+  // runs before every handler; throw to short-circuit the request
+})
+
+app.addHook('onListen', (server) => {
+  console.log(`Listening on ${server.url}`)
+})
+```
+
+## Plugins & context
+
+`register` mounts a group of routes under a prefix. Type the app with a context type to share data attached by hooks:
+
+```ts
+type Ctx = { user: { id: number } }
+
+app.register((users: MarciApp<Ctx>) => {
+  users.addHook('onRequest', (req) => { req.user = { id: 1 } })
+  users.get('/me', (req) => req.user)
+}, { prefix: '/users' })
+```
+
+For composable, reusable plugins there is the `marci()` builder. `use` adds plugins, `routes` adds handlers, and the result can be passed to `register`:
+
+```ts
+import { marci, MarciApp } from '@den59k/marci'
+
+const useAuth = (app: MarciApp<Ctx>) => {
+  app.addHook('onRequest', (req) => { req.user = { id: 1 } })
+}
+
+const users = marci<Ctx>()
+  .use(useAuth)
+  .routes((app) => {
+    app.get('/me', (req) => req.user)
+  })
+
+app.register(users, { prefix: '/users' })
+```
+
+## Errors
+
+Throw `HTTPError` to send an explicit status code; validation failures are turned into `400` responses automatically.
+
+```ts
+import { HTTPError } from '@den59k/marci'
+
+app.get('/secret', () => {
+  throw new HTTPError('Forbidden', 403)        // text body
+  // throw new HTTPError({ reason: 'forbidden' }, 403)  // JSON body
+})
+```
+
+## Testing
+
+`inject()` dispatches a request through your routes in-process — no server, no socket — and returns a real `Response`. It reuses the same routing, validation, and error handling as a live server.
+
+```ts
+import { test, expect } from 'bun:test'
+
+test('returns a user', async () => {
+  const res = await app.inject('/users/1')
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({ id: 1 })
+})
+
+// With a body:
+await app.inject({ method: 'POST', url: '/users', body: { name: 'Alice' } })
+```
+
+> Under `inject()` there is no Bun `Server`, so `req.server` is `undefined` and WebSocket upgrades are not exercised.
+
+## WebSockets
+
+```ts
+app.registerWsHandler('/ws', {
+  open(ws) { ws.send('hello') },
+  message(ws, msg) { ws.send(msg) },
+})
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,119 @@
+declare class HTTPError extends Error {
+	statusCode: number;
+	data?: any;
+	message: string;
+	constructor(message: string | object, statusCode?: number);
+}
+import { BunRequest, Server, HeadersInit, BodyInit } from "bun";
+import { SchemaItem, SchemaType } from "compact-json-schema";
+type RouteOptions = {
+	params?: SchemaItem
+	body?: SchemaItem
+	query?: SchemaItem
+};
+type GetRouteOptions = {
+	params?: SchemaItem
+	query?: SchemaItem
+};
+interface MarciContext {}
+type MarciRequest<
+	R extends object = {},
+	T extends RouteOptions = {}
+> = MarciContext & R & {
+	params: T["params"] extends object ? SchemaType<T["params"]> : unknown
+	query: T["query"] extends object ? SchemaType<T["query"]> : unknown
+	body: T["body"] extends object ? SchemaType<T["body"]> : unknown
+	raw: BunRequest
+	server: Server
+};
+type GetMarciRequest<
+	R extends object = {},
+	T extends GetRouteOptions = {}
+> = MarciContext & R & {
+	params: T["params"] extends object ? SchemaType<T["params"]> : unknown
+	query: T["query"] extends object ? SchemaType<T["query"]> : unknown
+	raw: BunRequest
+	server: Server
+};
+type RouteAction<
+	T extends RouteOptions,
+	R extends object = {}
+> = (req: MarciRequest<R, T>) => (any | Promise<any>);
+type GetRouteAction<
+	T extends GetRouteOptions,
+	R extends object = {}
+> = (req: GetMarciRequest<R, T>) => (any | Promise<any>);
+type RegisterPluginOptions = {
+	prefix?: string
+};
+type InjectOptions = {
+	method?: string
+	url: string
+	headers?: HeadersInit
+	body?: BodyInit | Record<string, any> | null
+};
+import { BunRequest as BunRequest3, Server as Server2, WebSocketHandler } from "bun";
+import { SchemaItem as SchemaItem3 } from "compact-json-schema";
+import { SchemaItem as SchemaItem2 } from "compact-json-schema";
+type GetOptionsFromSchemaList<T extends readonly SchemaItem2[]> = T extends [SchemaItem2] ? {
+	params: T[0]
+} : T extends [SchemaItem2, SchemaItem2] ? {
+	params: T[0]
+	query: T[1]
+} : {};
+type PostOptionsFromSchemaList<T extends readonly SchemaItem2[]> = T extends [SchemaItem2] ? {
+	params: T[0]
+} : T extends [SchemaItem2, SchemaItem2] ? {
+	params: T[0]
+	body: T[1]
+} : {};
+declare class MarciApp<R extends object = {}> {
+	private routes;
+	private promises;
+	private prefix;
+	private root;
+	private server;
+	private onListenHooks;
+	private onRequestHooks;
+	private add;
+	addHook(where: "onListen", callback: (server: Bun.Server2) => void): void;
+	addHook(where: "onRequest", callback: (ctx: MarciRequest<R>) => void): void;
+	get(path: string, callback: GetRouteAction<{}, R>): void;
+	get<T extends GetRouteOptions>(path: string, options: T, callback: GetRouteAction<T, R>): void;
+	get<T extends readonly SchemaItem3[]>(path: string, schemas: [...T], callback: GetRouteAction<GetOptionsFromSchemaList<T>, R>): void;
+	post(path: string, callback: RouteAction<{}, R>): void;
+	post<T extends RouteOptions>(path: string, options: T, callback: RouteAction<T, R>): void;
+	post<T extends readonly SchemaItem3[]>(path: string, schemas: [...T], callback: RouteAction<PostOptionsFromSchemaList<T>, R>): void;
+	put(path: string, callback: RouteAction<{}, R>): void;
+	put<T extends RouteOptions>(path: string, options: T, callback: RouteAction<T, R>): void;
+	put<T extends readonly SchemaItem3[]>(path: string, schemas: [...T], callback: RouteAction<PostOptionsFromSchemaList<T>, R>): void;
+	patch(path: string, callback: RouteAction<{}, R>): void;
+	patch<T extends RouteOptions>(path: string, options: T, callback: RouteAction<T, R>): void;
+	patch<T extends readonly SchemaItem3[]>(path: string, schemas: [...T], callback: RouteAction<PostOptionsFromSchemaList<T>, R>): void;
+	delete(path: string, callback: RouteAction<{}, R>): void;
+	delete<T extends RouteOptions>(path: string, options: T, callback: RouteAction<T, R>): void;
+	delete<T extends readonly SchemaItem3[]>(path: string, schemas: [...T], callback: RouteAction<PostOptionsFromSchemaList<T>, R>): void;
+	register(plugin: (app: MarciApp<any>) => void | Promise<void>, options?: RegisterPluginOptions): void;
+	private websocket?;
+	private websocketPath?;
+	private websocketFetch?;
+	registerWsHandler<T>(ws: WebSocketHandler<T>): void;
+	registerWsHandler<T>(path: string, ws: WebSocketHandler<T>): void;
+	registerWsHandler<T>(onFetch: (req: BunRequest3) => any, ws: WebSocketHandler<T>): void;
+	private fetch;
+	registerNotFoundHandler(handler: (path: string, req: Request, server: Server2) => Response | Promise<Response | undefined>): void;
+	listen(port?: number, hostname?: string): Promise<Bun.Server2>;
+	/** Converts a thrown error into the same Response Bun's `error` handler produces. */
+	private handleError;
+	/**\\n\\t\\n\\t* Dispatches a request through the app's routes in-process — no server, no\\n\\t\\n\\t* socket. Matches the route the same way Bun would, then runs the onRequest\\n\\t\\n\\t* hooks, validation, handler, and error mapping, returning the Response.\\n\\t\\n\\t* Intended for integration testing.\\n\\t\\n\\t*\\n\\t\\n\\t* @example\\n\\t\\n\\t* const res = await app.inject("/users/1")\\n\\t\\n\\t* const res = await app.inject({ method: "POST", url: "/users", body: { name: "Alice" } })\\n\\t\\n\\t* expect(res.status).toBe(200)\\n\\t\\n\\t* expect(await res.json()).toEqual({ ... })\\n\\t\\n\\t*/
+	inject(options: string | InjectOptions): Promise<Response>;
+}
+type MarciSyntax<R extends object = {}> = ((app: MarciApp<any>) => Promise<void>) & {
+	use<
+		S extends object = {},
+		A extends any[] = []
+	>(plugin: (app: MarciApp<R & S>, ...args: A) => Promise<void> | void, ...args: A): MarciSyntax<R & S>
+	routes(app: (app: MarciApp<R>) => Promise<void> | void): MarciSyntax<R>
+};
+declare const marci: <R extends object = {}>() => MarciSyntax<R>;
+export { marci, MarciSyntax, MarciRequest, MarciApp, InjectOptions, HTTPError };

package/dist/index.js

@@ -0,0 +1,426 @@
+// src/error.ts
+class HTTPError extends Error {
+  statusCode;
+  data;
+  message;
+  constructor(message, statusCode) {
+    super();
+    if (typeof message === "string") {
+      this.message = message;
+    } else if (typeof message === "object" && message !== null && !("error" in message)) {
+      this.data = { error: message };
+      this.message = "HTTP Error";
+    } else {
+      this.data = message;
+      this.message = "HTTP Error";
+    }
+    this.statusCode = statusCode ?? 400;
+  }
+}
+
+class ValidationError extends Error {
+  error;
+  where;
+  constructor(err, where) {
+    super(err.message);
+    this.error = err;
+    this.where = where;
+  }
+}
+
+// src/marci-syntax.ts
+var marci = () => {
+  const plugins = [];
+  const handlers = [];
+  const app = Object.assign(async (app2) => {
+    for (let plugin of plugins) {
+      await plugin[0](app2, ...plugin.slice(1));
+    }
+    for (let handler of handlers) {
+      await handler(app2);
+    }
+  }, {
+    use(plugin, ...args) {
+      plugins.push([plugin, ...args]);
+      return this;
+    },
+    routes(handler) {
+      handlers.push(handler);
+      return this;
+    }
+  });
+  return app;
+};
+// src/MarciApp.ts
+import { unfoldTypeBoxSchema } from "compact-json-schema";
+import { TypeBoxError } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+
+// src/request.ts
+import { Value } from "@sinclair/typebox/value";
+
+class MarciRequestInternal {
+  server;
+  raw;
+  params;
+  query;
+  body = null;
+  constructor(req, server, paramsSchema, querySchema) {
+    if (paramsSchema && paramsSchema.arrayKeys) {
+      const params = req.params;
+      for (let key of paramsSchema.arrayKeys) {
+        if (params[key] && !params[key].startsWith("[")) {
+          params[key] = params[key].split(",");
+        }
+      }
+      this.params = Value.Parse(paramsSchema, params);
+    } else {
+      this.params = paramsSchema === null ? req.params : Value.Parse(paramsSchema, req.params);
+    }
+    if (req.url.includes("?")) {
+      const queryParams = new URL(req.url).searchParams;
+      if (querySchema && querySchema.type === "object") {
+        const query = {};
+        for (let [key, value] of queryParams.entries()) {
+          const schema = querySchema.properties[key];
+          if (!schema)
+            continue;
+          if (schema.type === "boolean" && value === "") {
+            query[key] = true;
+            continue;
+          }
+          query[key] = Value.Parse(schema, value);
+        }
+        this.query = query;
+      } else {
+        this.query = Object.fromEntries(queryParams.entries());
+      }
+    } else if (querySchema) {
+      this.query = Value.Parse(querySchema, {});
+    } else {
+      this.query = null;
+    }
+    this.raw = req;
+    this.server = server;
+  }
+}
+
+// src/utils.ts
+import { Type } from "@sinclair/typebox";
+import { provideTypeBoxMap } from "compact-json-schema";
+var getRouteOptions = (method, schemas) => {
+  if (schemas.length === 0)
+    return {};
+  if (schemas.length === 1) {
+    return { params: schemas[0] };
+  }
+  if (method === "GET") {
+    return { params: schemas[0], query: schemas[1] };
+  } else {
+    if (schemas.length === 2) {
+      return { params: schemas[0], body: schemas[1] };
+    } else {
+      return { params: schemas[0], body: schemas[1], query: schemas[2] };
+    }
+  }
+};
+var getValidationError = (obj, step) => {
+  if (step) {
+    return `{"cause":"Validation error","where":"${step}","fields":{"${obj.path.slice(1)}":{"message":"${obj.message}"}}}`;
+  } else {
+    return `{"cause":"Validation error","fields":{"${obj.path.slice(1)}":{"message":"${obj.message}"}}}`;
+  }
+};
+provideTypeBoxMap({
+  string: Type.String,
+  boolean: Type.Boolean,
+  number: Type.Number,
+  integer: Type.Integer,
+  object: Type.Object,
+  array: Type.Array,
+  bigint: Type.BigInt,
+  union: Type.Union,
+  null: Type.Null,
+  literal: Type.Literal,
+  optional: Type.Optional,
+  any: Type.Any
+});
+var isDefault = (schema) => {
+  if (typeof schema !== "object" || schema === null)
+    return true;
+  for (let value of Object.values(schema)) {
+    if (value !== "string" && value !== "string?" && value !== "string??") {
+      return false;
+    }
+  }
+  return true;
+};
+var parseBody = (schema, req) => {
+  return new Promise((res, rej) => {
+    req.json().catch((e) => {
+      rej(new HTTPError(`Error on parsing body (${e.message})`, 400));
+    }).then((resp) => {
+      const check = schema.Check(resp);
+      if (!check) {
+        const error = schema.Errors(resp).First();
+        const err = new ValidationError(error, "body");
+        rej(err);
+      }
+      res(resp);
+    });
+  });
+};
+var matchSegments = (pattern, segments) => {
+  const patternSegments = pattern.split("/");
+  const params = {};
+  for (let i = 0;i < patternSegments.length; i++) {
+    const part = patternSegments[i];
+    if (i >= segments.length)
+      return null;
+    if (part === "*") {
+      return params;
+    }
+    if (part.startsWith(":")) {
+      params[part.slice(1)] = decodeURIComponent(segments[i]);
+    } else if (part !== segments[i]) {
+      return null;
+    }
+  }
+  return segments.length === patternSegments.length ? params : null;
+};
+var scorePattern = (pattern) => {
+  let score = 0;
+  for (const part of pattern.split("/")) {
+    if (part === "*")
+      score -= 1000;
+    else if (part.startsWith(":"))
+      score += 1;
+    else
+      score += 10;
+  }
+  return score;
+};
+var matchRoute = (routes, method, pathname) => {
+  const segments = pathname.split("/");
+  let best = null;
+  let bestScore = -Infinity;
+  for (const pattern in routes) {
+    const methods = routes[pattern];
+    if (!methods || typeof methods[method] !== "function")
+      continue;
+    const params = matchSegments(pattern, segments);
+    if (params === null)
+      continue;
+    const score = scorePattern(pattern);
+    if (score > bestScore) {
+      bestScore = score;
+      best = { handler: methods[method], params };
+    }
+  }
+  return best;
+};
+
+// src/MarciApp.ts
+class MarciApp {
+  routes = {};
+  promises = [];
+  prefix = "";
+  root = null;
+  server;
+  onListenHooks = [];
+  onRequestHooks = [];
+  add(path, method, _options, callback) {
+    let fullPath = this.prefix + (path.endsWith("/") ? path.slice(0, -1) : path) || "/";
+    if (!(fullPath in this.routes)) {
+      this.routes[fullPath] = {};
+    }
+    const options = Array.isArray(_options) ? getRouteOptions(method, _options) : _options;
+    const paramsSchema = options.params && !isDefault(options.params) ? unfoldTypeBoxSchema(options.params) : null;
+    const querySchema = options.query ? unfoldTypeBoxSchema(options.query) : null;
+    const bodyValidation = options.body ? TypeCompiler.Compile(unfoldTypeBoxSchema(options.body)) : null;
+    if (paramsSchema && paramsSchema.properties) {
+      const arrayKeys = Object.entries(paramsSchema.properties).filter((i) => i[1].type === "array").map((i) => i[0]);
+      if (arrayKeys.length > 0) {
+        paramsSchema.arrayKeys = arrayKeys;
+      }
+    }
+    this.routes[fullPath][method] = async (req) => {
+      const request = new MarciRequestInternal(req, this.root?.server ?? this.server, paramsSchema, querySchema);
+      for (const callback2 of this.onRequestHooks) {
+        await callback2(request);
+      }
+      const body = bodyValidation === null ? undefined : await parseBody(bodyValidation, req);
+      request.body = body;
+      const resp = await callback(request);
+      if (resp === undefined) {
+        return new Response;
+      } else if (resp instanceof Response) {
+        return resp;
+      } else {
+        return Response.json(resp);
+      }
+    };
+  }
+  addHook(where, callback) {
+    if (where === "onRequest") {
+      this.onRequestHooks.push(callback);
+    } else if (where === "onListen") {
+      this.onListenHooks.push(callback);
+    }
+  }
+  get(path, ...args) {
+    if (args.length === 1) {
+      this.add(path, "GET", {}, args[0]);
+    } else {
+      this.add(path, "GET", args[0], args[1]);
+    }
+  }
+  post(path, ...args) {
+    if (args.length === 1) {
+      this.add(path, "POST", {}, args[0]);
+    } else {
+      this.add(path, "POST", args[0], args[1]);
+    }
+  }
+  put(path, ...args) {
+    if (args.length === 1) {
+      this.add(path, "PUT", {}, args[0]);
+    } else {
+      this.add(path, "PUT", args[0], args[1]);
+    }
+  }
+  patch(path, ...args) {
+    if (args.length === 1) {
+      this.add(path, "PATCH", {}, args[0]);
+    } else {
+      this.add(path, "PATCH", args[0], args[1]);
+    }
+  }
+  delete(path, ...args) {
+    if (args.length === 1) {
+      this.add(path, "DELETE", {}, args[0]);
+    } else {
+      this.add(path, "DELETE", args[0], args[1]);
+    }
+  }
+  register(plugin, options = {}) {
+    const app = new MarciApp;
+    app.root = this.root ?? this;
+    app.routes = this.routes;
+    app.onListenHooks = this.onListenHooks;
+    app.prefix = this.prefix + (options.prefix ?? "");
+    const resp = plugin(app);
+    if (typeof resp === "object") {
+      this.promises.push(resp);
+    }
+  }
+  websocket;
+  websocketPath;
+  websocketFetch;
+  registerWsHandler(path, ws) {
+    if (typeof path === "string") {
+      this.websocket = ws;
+      this.websocketPath = path;
+    } else if (typeof path === "function") {
+      this.websocket = ws;
+      this.websocketFetch = path;
+    } else {
+      this.websocket = path;
+    }
+  }
+  fetch = async (req, server) => {
+    const path = new URL(req.url).pathname;
+    if ((!this.websocketPath || this.websocketPath.startsWith(path)) && this.websocket) {
+      const data = this.websocketFetch ? await this.websocketFetch(req) : {};
+      if (data instanceof Response) {
+        return data;
+      }
+      if (server.upgrade(req, { data })) {
+        return;
+      }
+    }
+    return new Response(`Route ${req.method}:${path} not found`, { status: 404 });
+  };
+  registerNotFoundHandler(handler) {
+    this.fetch = async (req, server) => {
+      const path = new URL(req.url).pathname;
+      if ((!this.websocketPath || this.websocketPath.startsWith(path)) && this.websocket) {
+        const data = this.websocketFetch ? await this.websocketFetch(req) : {};
+        if (data instanceof Response) {
+          return data;
+        }
+        if (server.upgrade(req, { data })) {
+          return;
+        }
+      }
+      const resp = await handler(path, req, server);
+      return resp;
+    };
+  }
+  async listen(port, hostname) {
+    if (this.promises.length > 0) {
+      await Promise.all(this.promises);
+    }
+    const server = Bun.serve({
+      routes: this.routes,
+      port,
+      hostname,
+      fetch: this.fetch,
+      websocket: this.websocket,
+      error: (err) => this.handleError(err)
+    });
+    this.server = server;
+    for (const callback of this.onListenHooks) {
+      await callback(server);
+    }
+    return server;
+  }
+  handleError(err) {
+    if (err instanceof HTTPError) {
+      if (err.data) {
+        return Response.json(err.data, { status: err.statusCode });
+      }
+      return new Response(err.message, { status: err.statusCode });
+    } else if (err instanceof TypeBoxError || err instanceof ValidationError) {
+      return new Response(getValidationError(err.error, err.where), { status: 400, headers: { "Content-Type": "application/json" } });
+    } else {
+      console.error(err);
+      return new Response(err.message, { status: 500 });
+    }
+  }
+  async inject(options) {
+    if (this.root)
+      return this.root.inject(options);
+    const opts = typeof options === "string" ? { url: options } : options;
+    if (this.promises.length > 0) {
+      await Promise.all(this.promises);
+    }
+    const method = (opts.method ?? "GET").toUpperCase();
+    const rawUrl = opts.url.includes("://") ? opts.url : "http://localhost" + (opts.url.startsWith("/") ? opts.url : "/" + opts.url);
+    const url = new URL(rawUrl);
+    const pathname = url.pathname;
+    const headers = new Headers(opts.headers);
+    let body = opts.body;
+    if (body !== undefined && body !== null && typeof body === "object" && !(body instanceof ReadableStream) && !(body instanceof Blob) && !(body instanceof FormData) && !(body instanceof URLSearchParams) && !(body instanceof ArrayBuffer) && !ArrayBuffer.isView(body)) {
+      body = JSON.stringify(body);
+      if (!headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    }
+    const req = new Request(url.href, { method, headers, body: body ?? undefined });
+    const match = matchRoute(this.routes, method, pathname);
+    if (!match) {
+      return this.fetch(req, { upgrade: () => false });
+    }
+    req.params = match.params;
+    try {
+      return await match.handler(req);
+    } catch (err) {
+      return this.handleError(err);
+    }
+  }
+}
+export {
+  marci,
+  MarciApp,
+  HTTPError
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "dynara",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "version": "0.0.1",
+  "description": "Simple HTTP framework powered by Bun",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/den59k/marci.git",
+    "directory": "packages/marci"
+  },
+  "scripts": {
+    "build": "bunx bunup src/index.ts --format esm",
+    "test": "bun test",
+    "release": "bun pm version patch"
+  },
+  "devDependencies": {
+    "bun-plugin-dts": "^0.3.0",
+    "bunup": "^0.8.58"
+  },
+  "peerDependencies": {
+    "@types/bun": "*",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.37",
+    "compact-json-schema": "^0.1.4"
+  },
+  "files": [
+    "dist"
+  ]
+}