@aura-stack/router 0.1.0

package/dist/router.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/router.ts
+var router_exports = {};
+__export(router_exports, {
+  createRouter: () => createRouter
+});
+module.exports = __toCommonJS(router_exports);
+
+// src/assert.ts
+var supportedBodyMethods = ["POST", "PUT", "PATCH"];
+var isSupportedBodyMethod = (method) => {
+  return supportedBodyMethods.includes(method);
+};
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+
+// src/endpoint.ts
+var createRoutePattern = (route) => {
+  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+};
+
+// src/context.ts
+var getRouteParams = (route, path) => {
+  const routeRegex = createRoutePattern(route);
+  if (!routeRegex.test(path)) {
+    throw new AuraStackRouterError("BAD_REQUEST", `Missing required route params for route: ${route}`);
+  }
+  const params = routeRegex.exec(route)?.slice(1).map((seg) => seg.replace(":", ""));
+  if (!params) return {};
+  const values = routeRegex.exec(path)?.slice(1);
+  return params.reduce(
+    (previous, now, idx) => ({
+      ...previous,
+      [now]: decodeURIComponent(values?.[idx] ?? "")
+    }),
+    {}
+  );
+};
+var getSearchParams = (url, config) => {
+  const route = new URL(url);
+  if (config.schemas?.searchParams) {
+    const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
+    if (!parsed.success) {
+      throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+    }
+    return parsed.data;
+  }
+  return new URLSearchParams(route.searchParams.toString());
+};
+var getHeaders = (request) => {
+  return new Headers(request.headers);
+};
+var getBody = async (request, config) => {
+  if (!isSupportedBodyMethod(request.method)) {
+    return void 0;
+  }
+  const contentType = request.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await request.json();
+    if (config.schemas?.body) {
+      const parsed = config.schemas.body.safeParse(json);
+      if (!parsed.success) {
+        throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+      }
+      return parsed.data;
+    }
+    return json;
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    return await request.formData();
+  }
+  if (contentType.includes("text/")) {
+    return await request.text();
+  }
+  if (contentType.includes("application/octet-stream")) {
+    return await request.arrayBuffer();
+  }
+  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
+    return await request.blob();
+  }
+  return null;
+};
+
+// src/middleware.ts
+var executeGlobalMiddlewares = async (request, middlewares) => {
+  if (!middlewares) return request;
+  for (const middleware of middlewares) {
+    if (typeof middleware !== "function") {
+      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+    }
+    const executed = await middleware(request);
+    if (executed instanceof Response) {
+      return executed;
+    }
+    request = executed;
+  }
+  if (!request || !(request instanceof Request)) {
+    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  }
+  return request;
+};
+var executeMiddlewares = async (request, context, middlewares = []) => {
+  try {
+    let ctx = context;
+    for (const middleware of middlewares) {
+      if (typeof middleware !== "function") {
+        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+      }
+      ctx = await middleware(request, ctx);
+    }
+    return ctx;
+  } catch {
+    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+  }
+};
+
+// src/router.ts
+var createRouter = (endpoints, config = {}) => {
+  const server = {};
+  const groups = {
+    GET: [],
+    POST: [],
+    DELETE: [],
+    PUT: [],
+    PATCH: []
+  };
+  endpoints.forEach((endpoint) => groups[endpoint.method].push(endpoint));
+  for (const method in groups) {
+    server[method] = async (request, ctx) => {
+      try {
+        const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
+        if (globalRequest instanceof Response) {
+          return globalRequest;
+        }
+        const url = new URL(globalRequest.url);
+        const pathname = url.pathname;
+        const endpoint = groups[method].find((endpoint2) => {
+          const withBasePath = config.basePath ? `${config.basePath}${endpoint2.route}` : endpoint2.route;
+          const regex = createRoutePattern(withBasePath);
+          return regex.test(pathname);
+        });
+        if (endpoint) {
+          const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
+          const body = await getBody(globalRequest, endpoint.config);
+          const params = getRouteParams(withBasePath, pathname);
+          const searchParams = getSearchParams(globalRequest.url, endpoint.config);
+          const headers = getHeaders(globalRequest);
+          const context = {
+            ...ctx,
+            params,
+            searchParams,
+            headers,
+            body
+          };
+          await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
+          return endpoint.handler(globalRequest, context);
+        }
+        return Response.json({ message: "Not Found" }, { status: 404 });
+      } catch (error) {
+        if (error instanceof AuraStackRouterError) {
+          const { message, status, statusText: statusText2 } = error;
+          console.log("StatusText: ", statusText2);
+          return Response.json({ message }, { status, statusText: statusText2 });
+        }
+        return Response.json({ message: "Internal Server Error" }, { status: 500 });
+      }
+    };
+  }
+  return server;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRouter
+});

package/dist/router.d.cts

@@ -0,0 +1,15 @@
+import { RouteEndpoint, RouterConfig, GetHttpHandlers } from './types.cjs';
+import 'zod';
+
+/**
+ * Creates the entry point for the server, handling the endpoints defined in the router.
+ * It groups endpoints by HTTP method and matches incoming requests to the appropriate endpoint.
+ * It accepts an optional configuration object to set a base path and middlewares for all endpoints.
+ *
+ * @param endpoints - Array of route endpoints to be handled by the router
+ * @param config - Optional configuration object for the router
+ * @returns An object with methods corresponding to HTTP methods, each handling requests for that method
+ */
+declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => GetHttpHandlers<Endpoints>;
+
+export { createRouter };

package/dist/router.d.ts

@@ -0,0 +1,15 @@
+import { RouteEndpoint, RouterConfig, GetHttpHandlers } from './types.js';
+import 'zod';
+
+/**
+ * Creates the entry point for the server, handling the endpoints defined in the router.
+ * It groups endpoints by HTTP method and matches incoming requests to the appropriate endpoint.
+ * It accepts an optional configuration object to set a base path and middlewares for all endpoints.
+ *
+ * @param endpoints - Array of route endpoints to be handled by the router
+ * @param config - Optional configuration object for the router
+ * @returns An object with methods corresponding to HTTP methods, each handling requests for that method
+ */
+declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => GetHttpHandlers<Endpoints>;
+
+export { createRouter };

package/dist/router.js

@@ -0,0 +1,11 @@
+import {
+  createRouter
+} from "./chunk-VBI7H3AK.js";
+import "./chunk-NNCUFWPI.js";
+import "./chunk-6UBPSXKR.js";
+import "./chunk-ENOBC3XN.js";
+import "./chunk-RVJ2F7OL.js";
+import "./chunk-RFYOPPMW.js";
+export {
+  createRouter
+};

package/dist/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/types.d.cts

@@ -0,0 +1,134 @@
+import { ZodObject, z } from 'zod';
+
+/**
+ * Route pattern must start with a slash and can contain parameters prefixed with a colon.
+ * @example
+ * const getUser:RoutePattern = "/users/:userId"
+ * const getPostsComments:RoutePattern = "/posts/:postId/comments/:commentId"
+ */
+type RoutePattern = `/${string}`;
+/**
+ * HTTP methods supported by the router.
+ */
+type HTTPMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH";
+/**
+ * Content types supported by the router.
+ */
+type ContentType = "application/json" | "application/x-www-form-urlencoded" | "text/plain";
+type Prettify<Obj extends object> = {
+    [Key in keyof Obj]: Obj[Key];
+} & {};
+/**
+ * Extracts route parameters from a given route pattern through colon-prefixed segments.
+ * Returns an object type where keys are parameter names and values are strings.
+ * If no parameters are found, returns an empty object type.
+ *
+ * @example
+ * // Expected: { userId: string }
+ * type UserParams = Params<"/users/:userId">;
+ *
+ * // Expected: { postId: string; commentId: string }
+ * type PostCommentParams = Params<"/posts/:postId/comments/:commentId">;
+ *
+ * // Expected: {}
+ * type NoParams = Params<"/about">;
+ */
+type Params<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
+    [K in Param]: string;
+} & Params<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
+    [K in Param]: string;
+}> : Route extends `/:${infer Param}` ? Prettify<{
+    [K in Param]: string;
+}> : {};
+type GetRouteParams<T extends RoutePattern> = Params<T>;
+/**
+ * Available schemas validation for an endpoint. It can include body and searchParams schemas.
+ */
+interface EndpointSchemas {
+    body?: ZodObject<any>;
+    searchParams?: ZodObject<any>;
+}
+/**
+ * Configuration for an endpoint, including optional schemas for request validation and middlewares.
+ */
+type EndpointConfig<RouteParams extends RoutePattern = RoutePattern, Schemas extends EndpointSchemas = EndpointSchemas> = Prettify<{
+    schemas?: Schemas;
+    middlewares?: MiddlewareFunction<GetRouteParams<RouteParams>, {
+        schemas: Schemas;
+    }>[];
+}>;
+/**
+ * Infer the type of search parameters from the provided value in the `EndpointConfig`.
+ */
+type ContextSearchParams<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
+    searchParams: ZodObject;
+} ? {
+    searchParams: z.infer<Schemas["searchParams"]>;
+} : {
+    searchParams: URLSearchParams;
+};
+/**
+ * Infer the type of body from the provided value in the `EndpointConfig`.
+ */
+type ContextBody<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
+    body: ZodObject;
+} ? {
+    body: z.infer<Schemas["body"]>;
+} : {
+    body: undefined;
+};
+/**
+ * Context object passed to route handlers and middlewares defined in the
+ * `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
+ */
+interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
+    params: RouteParams;
+    headers: Headers;
+    body: ContextBody<Config["schemas"]>["body"];
+    searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
+}
+/**
+ * Global middleware function type that represent a function that runs before the route matching.
+ */
+type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
+/**
+ * Middleware function type that represent a function that runs before the route handler
+ * defined in the `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
+ */
+type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<RouteParams, Config>>) => Promise<RequestContext<RouteParams, Config>>;
+/**
+ * Defines a route handler function that processes an incoming request and returns a response.
+ * The handler receives the request object and a context containing route parameters, headers,
+ * and optionally validated body and search parameters based on the endpoint configuration.
+ */
+type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Promise<Response>;
+/**
+ * Represents a route endpoint definition, specifying the HTTP method, route pattern,
+ * handler function with inferred context types, and associated configuration.
+ */
+interface RouteEndpoint<Method extends HTTPMethod = HTTPMethod, Route extends RoutePattern = RoutePattern, Config extends EndpointConfig = EndpointConfig> {
+    method: Method;
+    route: Route;
+    handler: RouteHandler<Route, Config>;
+    config: Config;
+}
+/**
+ * Infer the HTTP methods defined in the provided array of route endpoints.
+ */
+type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[] ? Endpoints[number]["method"] : "unknown";
+/**
+ * Generates an object with HTTP methods available by the router from `createRouter` function.
+ * Each method is a function that takes a request and context, returning a promise of a response.
+ */
+type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
+    [Method in InferMethod<Endpoints>]: (req: Request, ctx: RequestContext) => Promise<Response>;
+};
+/**
+ * Configuration options for `createRouter` function.
+ */
+interface RouterConfig {
+    basePath?: RoutePattern;
+    middlewares?: GlobalMiddleware[];
+}
+
+export type { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+import { ZodObject, z } from 'zod';
+
+/**
+ * Route pattern must start with a slash and can contain parameters prefixed with a colon.
+ * @example
+ * const getUser:RoutePattern = "/users/:userId"
+ * const getPostsComments:RoutePattern = "/posts/:postId/comments/:commentId"
+ */
+type RoutePattern = `/${string}`;
+/**
+ * HTTP methods supported by the router.
+ */
+type HTTPMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH";
+/**
+ * Content types supported by the router.
+ */
+type ContentType = "application/json" | "application/x-www-form-urlencoded" | "text/plain";
+type Prettify<Obj extends object> = {
+    [Key in keyof Obj]: Obj[Key];
+} & {};
+/**
+ * Extracts route parameters from a given route pattern through colon-prefixed segments.
+ * Returns an object type where keys are parameter names and values are strings.
+ * If no parameters are found, returns an empty object type.
+ *
+ * @example
+ * // Expected: { userId: string }
+ * type UserParams = Params<"/users/:userId">;
+ *
+ * // Expected: { postId: string; commentId: string }
+ * type PostCommentParams = Params<"/posts/:postId/comments/:commentId">;
+ *
+ * // Expected: {}
+ * type NoParams = Params<"/about">;
+ */
+type Params<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
+    [K in Param]: string;
+} & Params<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
+    [K in Param]: string;
+}> : Route extends `/:${infer Param}` ? Prettify<{
+    [K in Param]: string;
+}> : {};
+type GetRouteParams<T extends RoutePattern> = Params<T>;
+/**
+ * Available schemas validation for an endpoint. It can include body and searchParams schemas.
+ */
+interface EndpointSchemas {
+    body?: ZodObject<any>;
+    searchParams?: ZodObject<any>;
+}
+/**
+ * Configuration for an endpoint, including optional schemas for request validation and middlewares.
+ */
+type EndpointConfig<RouteParams extends RoutePattern = RoutePattern, Schemas extends EndpointSchemas = EndpointSchemas> = Prettify<{
+    schemas?: Schemas;
+    middlewares?: MiddlewareFunction<GetRouteParams<RouteParams>, {
+        schemas: Schemas;
+    }>[];
+}>;
+/**
+ * Infer the type of search parameters from the provided value in the `EndpointConfig`.
+ */
+type ContextSearchParams<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
+    searchParams: ZodObject;
+} ? {
+    searchParams: z.infer<Schemas["searchParams"]>;
+} : {
+    searchParams: URLSearchParams;
+};
+/**
+ * Infer the type of body from the provided value in the `EndpointConfig`.
+ */
+type ContextBody<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
+    body: ZodObject;
+} ? {
+    body: z.infer<Schemas["body"]>;
+} : {
+    body: undefined;
+};
+/**
+ * Context object passed to route handlers and middlewares defined in the
+ * `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
+ */
+interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
+    params: RouteParams;
+    headers: Headers;
+    body: ContextBody<Config["schemas"]>["body"];
+    searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
+}
+/**
+ * Global middleware function type that represent a function that runs before the route matching.
+ */
+type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
+/**
+ * Middleware function type that represent a function that runs before the route handler
+ * defined in the `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
+ */
+type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<RouteParams, Config>>) => Promise<RequestContext<RouteParams, Config>>;
+/**
+ * Defines a route handler function that processes an incoming request and returns a response.
+ * The handler receives the request object and a context containing route parameters, headers,
+ * and optionally validated body and search parameters based on the endpoint configuration.
+ */
+type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Promise<Response>;
+/**
+ * Represents a route endpoint definition, specifying the HTTP method, route pattern,
+ * handler function with inferred context types, and associated configuration.
+ */
+interface RouteEndpoint<Method extends HTTPMethod = HTTPMethod, Route extends RoutePattern = RoutePattern, Config extends EndpointConfig = EndpointConfig> {
+    method: Method;
+    route: Route;
+    handler: RouteHandler<Route, Config>;
+    config: Config;
+}
+/**
+ * Infer the HTTP methods defined in the provided array of route endpoints.
+ */
+type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[] ? Endpoints[number]["method"] : "unknown";
+/**
+ * Generates an object with HTTP methods available by the router from `createRouter` function.
+ * Each method is a function that takes a request and context, returning a promise of a response.
+ */
+type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
+    [Method in InferMethod<Endpoints>]: (req: Request, ctx: RequestContext) => Promise<Response>;
+};
+/**
+ * Configuration options for `createRouter` function.
+ */
+interface RouterConfig {
+    basePath?: RoutePattern;
+    middlewares?: GlobalMiddleware[];
+}
+
+export type { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@aura-stack/router",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./router": {
+      "types": "./dist/router.d.ts",
+      "import": "./dist/router.js",
+      "require": "./dist/router.cjs"
+    },
+    "./endpoint": {
+      "types": "./dist/endpoint.d.ts",
+      "import": "./dist/endpoint.js",
+      "require": "./dist/endpoint.cjs"
+    },
+    "./types": "./dist/types.d.ts"
+  },
+  "keywords": [
+    "router",
+    "endpoints",
+    "api",
+    "aura",
+    "aura stack",
+    "typescript",
+    "nodejs"
+  ],
+  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.1.11"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}