serverstruct 0.2.0 → 0.4.0

package/README.md

@@ -1,194 +1,185 @@
 # Serverstruct
 
-⚡️ Typesafe and modular servers with [Hono](https://github.com/honojs/hono).
+⚡️ Typesafe and modular servers with [H3](https://github.com/unjs/h3).
 
-Serverstruct is a simple tool for building fast, modular and typesafe server applications.
-
-It provides structure to your Hono application without any limitations. It also supports dependency injection using [Hollywood DI](https://github.com/eriicafes/hollywood-di).
+Serverstruct provides simple helpers for building modular h3 applications with dependency injection using [getbox](https://github.com/eriicafes/getbox).
 
 ## Installation
 
-Serverstruct requires you to install hono.
-
 ```sh
-npm i serverstruct hono
+npm i serverstruct h3 getbox
 ```
 
-To make use of dependency injection provided by serverstruct, also install hollywood-di.
-
-```sh
-npm i serverstruct hono hollywood-di
-```
+## Quick Start
 
-## Usage
+```typescript
+import { application } from "serverstruct";
 
-### A simple app
+const app = application((app) => {
+  app.get("/", () => "Hello world!");
+});
 
-```ts
-import { createRoute } from "serverstruct";
+app.serve({ port: 3000 });
+```
 
-const app = createRoute()
-  .route((app) => {
-    return app.get("/", (c) => c.text("Hello world!"));
-  })
-  .app();
+## Composing Apps
 
-export default app;
-```
+Create modular h3 apps and mount them together:
 
-### An app with subroutes
+```typescript
+import { application } from "serverstruct";
 
-```ts
-import { createRoute } from "serverstruct";
+// Create a users module
+const { app: usersApp } = application((app) => {
+  const users: User[] = [];
 
-// users routes
-const users = createRoute().route((app) => {
-  return app.get("/", (c) => c.text("users"));
+  app.get("/", () => users);
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    users.push(body);
+    return body;
+  });
 });
 
-// posts routes
-const posts = createRoute().route((app) => {
-  return app.get("/", (c) => c.text("posts"));
+// Compose in main app
+const app = application((app) => {
+  app.get("/ping", () => "pong");
+  app.mount("/users", usersApp);
 });
 
-const app = createRoute()
-  .subroutes({ users, posts })
-  .route((app, container, routes) => {
-    return app
-      .get("/", (c) => c.text("Hello world!"))
-      .route("/users", routes.users)
-      .route("/posts", routes.posts);
-  })
-  .app();
-
-export default app;
+app.serve({ port: 3000 });
 ```
 
-## Route
+You can also create and return a new H3 instance to customize H3 options:
 
-A route returns a new Hono app and may compose other routes with `subroutes<{ ... }>()`. If you intend to utilize dependency injection, a route can require it's dependencies with `use<{ ... }>()` and provide new dependencies with `provide({ ... })`. A route with dependencies can only be added as a subroute to another route if that route satisfies it's dependencies.
+```typescript
+import { H3 } from "h3";
 
-```ts
-const auth = createRoute().route((app) => {
-  return app; // chain route handlers here
+const app = application(() => {
+  const customApp = new H3({
+    onError: (error) => {
+      console.error(error);
+    },
+  });
+  customApp.get("/", () => "Hello from custom app!");
+  return customApp;
 });
+```
+
+## Controllers with Dependency Injection
 
-const users = createRoute().route((app) => {
-  return app; // chain route handlers here
+Use `controller()` to create reusable modules with shared dependencies. It integrates with [getbox](https://github.com/eriicafes/getbox) for dependency injection:
+
+```typescript
+import { application, controller } from "serverstruct";
+
+// Define a controller
+const usersController = controller((app) => {
+  const users: User[] = [];
+
+  app.get("/", () => users);
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    users.push(body);
+    return body;
+  });
 });
 
-const posts = createRoute().route((app) => {
-  return app; // chain route handlers here
+// Use it in your main app
+const app = application((app, box) => {
+  app.get("/ping", () => "pong");
+  app.mount("/users", box.new(usersController));
 });
 
-const app = createRoute()
-  .subroutes({ auth, users, posts })
-  .route((app, container, routes) => {
-    return app
-      .route("/auth", routes.auth)
-      .route("/users", routes.users)
-      .route("/posts", routes.posts);
-  })
-  .app();
+app.serve({ port: 3000 });
 ```
 
-Subroutes are not automatically registered. You will have to manually add the route for the desired path. This also allows for Hono's type inference through method chaining.
+The `box` parameter is a getbox `Box` instance that manages dependency instances.
 
-## Dependency Injection
+## Sharing Dependencies
 
-Serverstruct is designed to work with [Hollywood DI](https://github.com/eriicafes/hollywood-di). Routes can define their dependencies using `use`, and also register new tokens using `provide` which creates a child container.
+Controllers can share dependencies using the `box` parameter.
 
-A root container can also be passed to the route. If no container is explicitly provided the first call to provide creates a root container and futher calls to provide will inherit from it.
+Use `box.get(Class)` to retrieve or create a singleton instance:
 
-### Use
+```typescript
+import { application, controller } from "serverstruct";
 
-Define route dependencies. The route can then only be used in a context that satisfies it's dependencies.
+// A shared service
+class Database {
+  users: User[] = [];
 
-You can only call `use` once and only before calling `provide`.
-
-```ts
-interface Counter {
-  count: number;
-  increment(): void;
+  getUsers() { return this.users; }
+  addUser(user: User) { this.users.push(user); }
 }
 
-const route = createRoute()
-  .use<{ counter: Counter }>()
-  .route((app, container) => {
-    return app.get("/", (c) => {
-      container.counter.increment();
-      return c.text(`Count is: ${container.counter.count}`);
-    });
+// Controller uses box to access the database
+const usersController = controller((app, box) => {
+  const db = box.get(Database);
+
+  app.get("/", () => db.getUsers());
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    db.addUser(body);
+    return body;
   });
+});
 
-class LinearCounter {
-  public count = 0;
-  public increment() {
-    this.count++;
-  }
-}
+// Another controller can access the same database
+const statsController = controller((app, box) => {
+  const db = box.get(Database);
 
-// as a subroute
-const app = createRoute()
-  .provide({ counter: LinearCounter }) // the main app provides the dependency
-  .subroutes({ countRoute: route })
-  .route((app, _, routes) => {
-    return app.route("/count", routes.countRoute);
-  })
-  .app();
-
-// or as the main app
-const container = Hollywood.create({ counter: LinearCounter }); // the container provides the dependency
-const app = route.app(container);
-```
+  app.get("/count", () => ({ count: db.getUsers().length }));
+});
 
-Calling `Route.app()` returns the Hono instance from the route, therefore if the route has dependencies (by calling `use`), a container that satisfies those dependencies must be provided as seen in the example above.
+const app = application((app, box) => {
+  app.mount("/users", box.new(usersController));
+  app.mount("/stats", box.new(statsController));
+});
 
-### Provide
+await app.serve({ port: 3000 });
+```
 
-Provide creates a new child container. Registered tokens can then be used in the route and in futher calls to `provide`. See more about register tokens in [Hollywood DI](https://github.com/eriicafes/hollywood-di#tokens).
+`box.get(Class)` creates the instance on first call, then caches it.
 
-```ts
-import { defineInit } from "hollywood-di";
-import { createRoute } from "serverstruct";
+## Middleware
 
-class Foo {}
-class Bar {
-  public static init = defineInit(Bar).args("foo");
+Use h3's native middleware with `app.use()`:
 
-  constructor(public foo: Foo) {}
-}
+```typescript
+const app = application((app) => {
+  // Global middleware
+  app.use(() => console.log("Request received"));
 
-const route = createRoute()
-  .provide({
-    foo: Foo,
-    bar: Bar,
-  })
-  .route((app, container) => {
-    return app;
-  });
+  app.get("/", () => "Hello world!");
+});
 ```
 
-## Incremental Adoption
+Controllers can have their own middleware:
 
-Serverstruct can be added to an existing Hono app.
+```typescript
+const usersController = controller((app) => {
+  // Runs only for routes in this controller
+  app.use(() => console.log("Users route accessed"));
 
-```ts
-// routes/posts.ts
-export const postsRoute = createRoute().route((app) => {
-  return app.get("/", (c) => {
-    return c.text("posts");
-  });
+  app.get("/", () => [...]);
+  app.post("/", async () => {...});
 });
+```
+
+## Custom Box Instance
+
+Pass your own Box instance to `application()` for more control:
 
-import { Hono } from "hono";
-import { createRoute } from "serverstruct";
-import { postsRoute } from "./routes/posts";
+```typescript
+import { Box } from "getbox";
 
-const app = new Hono();
+const box = new Box();
 
-app.get("/", (c) => c.text("Hello world!"));
-app.route("/posts", postsRoute.app());
+// Pre-populate with dependencies
+Box.mock(box, Database, new Database());
 
-export default app;
+const app = application((app, box) => {
+  app.mount("/users", box.new(usersController));
+}, box);
 ```

package/dist/index.cjs

@@ -0,0 +1,82 @@
+let h3 = require("h3");
+let getbox = require("getbox");
+
+//#region src/index.ts
+/**
+* Creates an h3 application with dependency injection support.
+*
+* @param fn - Function that configures the app. Receives a fresh H3 instance
+*             and Box instance. Can add routes to the provided app, or create
+*             and return a new H3 instance.
+* @param box - Optional Box instance. If not provided, creates a new one.
+* @returns Object with `app` (H3 instance) and `serve` method.
+*
+* @example
+* ```typescript
+* const app = application((app) => {
+*   app.get("/", () => "Hello world!");
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*
+* @example With dependency injection
+* ```typescript
+* const app = application((app, box) => {
+*   app.get("/ping", () => "pong");
+*   app.mount("/users", box.new(usersController));
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*/
+function application(fn, box = new getbox.Box()) {
+	const defaultApp = new h3.H3();
+	const app = fn(defaultApp, box) || defaultApp;
+	return {
+		app,
+		serve: (options) => (0, h3.serve)(app, options)
+	};
+}
+/**
+* Creates a Constructor that produces an h3 app when resolved.
+*
+* Use `box.new(controller)` to create fresh controller instances.
+* Controllers can use `box.get()` to access shared dependencies.
+*
+* @param fn - Function that configures the controller.
+* @returns A Constructor that can be resolved via `box.new(controller)`.
+*
+* @example
+* ```typescript
+* // Define a controller
+* const usersController = controller((app, box) => {
+*   app.get("/", () => ["Alice", "Bob"]);
+* });
+*
+* // Use it in your app
+* const app = application((app, box) => {
+*   app.mount("/users", box.new(usersController));
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Controller with shared dependencies
+* class Database {
+*   getUsers() { return ["Alice", "Bob"]; }
+* }
+*
+* const usersController = controller((app, box) => {
+*   const db = box.get(Database);
+*   app.get("/", () => db.getUsers());
+* });
+* ```
+*/
+function controller(fn) {
+	return (0, getbox.factory)((box) => application(fn, box).app);
+}
+
+//#endregion
+exports.application = application;
+exports.controller = controller;

package/dist/index.d.cts

@@ -0,0 +1,75 @@
+import { H3, serve } from "h3";
+import { Box, Constructor } from "getbox";
+
+//#region src/index.d.ts
+type ServeOptions = Parameters<typeof serve>[1];
+/**
+ * Creates an h3 application with dependency injection support.
+ *
+ * @param fn - Function that configures the app. Receives a fresh H3 instance
+ *             and Box instance. Can add routes to the provided app, or create
+ *             and return a new H3 instance.
+ * @param box - Optional Box instance. If not provided, creates a new one.
+ * @returns Object with `app` (H3 instance) and `serve` method.
+ *
+ * @example
+ * ```typescript
+ * const app = application((app) => {
+ *   app.get("/", () => "Hello world!");
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ *
+ * @example With dependency injection
+ * ```typescript
+ * const app = application((app, box) => {
+ *   app.get("/ping", () => "pong");
+ *   app.mount("/users", box.new(usersController));
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ */
+declare function application(fn: (app: H3, box: Box) => H3 | void, box?: Box): {
+  app: H3;
+  serve: (options?: ServeOptions) => ReturnType<typeof serve>;
+};
+/**
+ * Creates a Constructor that produces an h3 app when resolved.
+ *
+ * Use `box.new(controller)` to create fresh controller instances.
+ * Controllers can use `box.get()` to access shared dependencies.
+ *
+ * @param fn - Function that configures the controller.
+ * @returns A Constructor that can be resolved via `box.new(controller)`.
+ *
+ * @example
+ * ```typescript
+ * // Define a controller
+ * const usersController = controller((app, box) => {
+ *   app.get("/", () => ["Alice", "Bob"]);
+ * });
+ *
+ * // Use it in your app
+ * const app = application((app, box) => {
+ *   app.mount("/users", box.new(usersController));
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Controller with shared dependencies
+ * class Database {
+ *   getUsers() { return ["Alice", "Bob"]; }
+ * }
+ *
+ * const usersController = controller((app, box) => {
+ *   const db = box.get(Database);
+ *   app.get("/", () => db.getUsers());
+ * });
+ * ```
+ */
+declare function controller(fn: (app: H3, box: Box) => H3 | void): Constructor<H3>;
+//#endregion
+export { ServeOptions, application, controller };

package/dist/index.d.mts

@@ -1,41 +1,75 @@
-import { AnyHollywood, HollywoodOf, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
-import { Env, Schema, Hono } from 'hono';
-import { BlankEnv, BlankSchema } from 'hono/types';
+import { H3, serve } from "h3";
+import { Box, Constructor } from "getbox";
 
-type Merge<T, To> = T & Omit<To, keyof T>;
-type IsEmptyObject<T> = keyof T extends never ? true : false;
-type KnownKey<T> = string extends T ? never : number extends T ? never : symbol extends T ? never : T;
-type KnownMappedKeys<T> = {
-    [K in keyof T as KnownKey<K>]: T[K];
-} & {};
-
-type Subroute<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any>;
+//#region src/index.d.ts
+type ServeOptions = Parameters<typeof serve>[1];
+/**
+ * Creates an h3 application with dependency injection support.
+ *
+ * @param fn - Function that configures the app. Receives a fresh H3 instance
+ *             and Box instance. Can add routes to the provided app, or create
+ *             and return a new H3 instance.
+ * @param box - Optional Box instance. If not provided, creates a new one.
+ * @returns Object with `app` (H3 instance) and `serve` method.
+ *
+ * @example
+ * ```typescript
+ * const app = application((app) => {
+ *   app.get("/", () => "Hello world!");
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ *
+ * @example With dependency injection
+ * ```typescript
+ * const app = application((app, box) => {
+ *   app.get("/ping", () => "pong");
+ *   app.mount("/users", box.new(usersController));
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ */
+declare function application(fn: (app: H3, box: Box) => H3 | void, box?: Box): {
+  app: H3;
+  serve: (options?: ServeOptions) => ReturnType<typeof serve>;
 };
-type Subroutes<TContainer extends Record<string, any> = any> = Record<string, Subroute<TContainer>>;
-type InferSubroutes<R extends Subroutes = {}> = {
-    [K in keyof R]: R[K] extends Route<any, infer App, any> ? App : never;
-} & {};
-declare class Route<Deps extends Record<string, any>, App extends Hono<any, any>, Routes extends Subroutes> {
-    private route;
-    private context;
-    constructor(route: (app: Hono<any, any>, container: any, routes: InferSubroutes<Routes>) => App, context: [
-        tokens: {
-            tokens: RegisterTokens<any, any>;
-            options?: ContainerOptions;
-        } | undefined,
-        routes: Subroutes<any>
-    ][]);
-    app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(container?: never): IsEmptyObject<Deps> extends true ? App : never;
-}
-declare class RouteBuilder<Deps extends Record<string, any>, Container extends AnyHollywood | undefined, E extends Env, S extends Schema, Routes extends Subroutes> {
-    private context;
-    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : RouteBuilder<T, HollywoodOf<T>, E, S, Routes>;
-    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): RouteBuilder<Deps, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>, E, S, Routes>;
-    subroutes<T extends Subroutes<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(routes: T): RouteBuilder<Deps, Container, E, S, Merge<T, Routes> extends infer T_1 ? { [K in keyof T_1]: Merge<T, Routes>[K]; } : never>;
-    route<App extends Hono<any, any>>(fn: (app: Hono<E, S>, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, routes: InferSubroutes<Routes>) => App): Route<Deps, App, Routes>;
-}
-declare function createRoute<E extends Env = BlankEnv>(): RouteBuilder<{}, undefined, E, BlankSchema, {}>;
-
-export { createRoute };
+/**
+ * Creates a Constructor that produces an h3 app when resolved.
+ *
+ * Use `box.new(controller)` to create fresh controller instances.
+ * Controllers can use `box.get()` to access shared dependencies.
+ *
+ * @param fn - Function that configures the controller.
+ * @returns A Constructor that can be resolved via `box.new(controller)`.
+ *
+ * @example
+ * ```typescript
+ * // Define a controller
+ * const usersController = controller((app, box) => {
+ *   app.get("/", () => ["Alice", "Bob"]);
+ * });
+ *
+ * // Use it in your app
+ * const app = application((app, box) => {
+ *   app.mount("/users", box.new(usersController));
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Controller with shared dependencies
+ * class Database {
+ *   getUsers() { return ["Alice", "Bob"]; }
+ * }
+ *
+ * const usersController = controller((app, box) => {
+ *   const db = box.get(Database);
+ *   app.get("/", () => db.getUsers());
+ * });
+ * ```
+ */
+declare function controller(fn: (app: H3, box: Box) => H3 | void): Constructor<H3>;
+//#endregion
+export { ServeOptions, application, controller };

package/dist/index.mjs

@@ -1,68 +1,81 @@
-// src/route.ts
-import {
-  Hollywood
-} from "hollywood-di";
-import { Hono } from "hono";
-var Route = class {
-  constructor(route, context) {
-    this.route = route;
-    this.context = context;
-  }
-  app(container) {
-    var _a;
-    let currentContainer = container;
-    const resolvedRoutes = {};
-    for (const [tokens, subroutes] of this.context) {
-      let subContainer = currentContainer;
-      if (tokens && subContainer) {
-        subContainer = Hollywood.createWithParent(
-          subContainer,
-          tokens.tokens,
-          tokens.options
-        );
-      } else if (tokens) {
-        subContainer = Hollywood.create(tokens.tokens, tokens.options);
-      }
-      currentContainer = subContainer;
-      for (const [key, subroute] of Object.entries(subroutes)) {
-        resolvedRoutes[key] = subroute.app(subContainer);
-      }
-    }
-    const instances = (_a = currentContainer == null ? void 0 : currentContainer.instances) != null ? _a : {};
-    return this.route(
-      new Hono(),
-      instances,
-      resolvedRoutes
-    );
-  }
-};
-var RouteBuilder = class {
-  constructor() {
-    this.context = [];
-  }
-  use() {
-    return this;
-  }
-  provide(tokens, options) {
-    this.context.push([{ tokens, options }, {}]);
-    return this;
-  }
-  subroutes(routes) {
-    if (!this.context.length)
-      this.context.push([void 0, routes]);
-    else {
-      const [, subroutes] = this.context[this.context.length - 1];
-      Object.assign(subroutes, routes);
-    }
-    return this;
-  }
-  route(fn) {
-    return new Route(fn, this.context);
-  }
-};
-function createRoute() {
-  return new RouteBuilder();
+import { H3, serve } from "h3";
+import { Box, factory } from "getbox";
+
+//#region src/index.ts
+/**
+* Creates an h3 application with dependency injection support.
+*
+* @param fn - Function that configures the app. Receives a fresh H3 instance
+*             and Box instance. Can add routes to the provided app, or create
+*             and return a new H3 instance.
+* @param box - Optional Box instance. If not provided, creates a new one.
+* @returns Object with `app` (H3 instance) and `serve` method.
+*
+* @example
+* ```typescript
+* const app = application((app) => {
+*   app.get("/", () => "Hello world!");
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*
+* @example With dependency injection
+* ```typescript
+* const app = application((app, box) => {
+*   app.get("/ping", () => "pong");
+*   app.mount("/users", box.new(usersController));
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*/
+function application(fn, box = new Box()) {
+	const defaultApp = new H3();
+	const app = fn(defaultApp, box) || defaultApp;
+	return {
+		app,
+		serve: (options) => serve(app, options)
+	};
 }
-export {
-  createRoute
-};
+/**
+* Creates a Constructor that produces an h3 app when resolved.
+*
+* Use `box.new(controller)` to create fresh controller instances.
+* Controllers can use `box.get()` to access shared dependencies.
+*
+* @param fn - Function that configures the controller.
+* @returns A Constructor that can be resolved via `box.new(controller)`.
+*
+* @example
+* ```typescript
+* // Define a controller
+* const usersController = controller((app, box) => {
+*   app.get("/", () => ["Alice", "Bob"]);
+* });
+*
+* // Use it in your app
+* const app = application((app, box) => {
+*   app.mount("/users", box.new(usersController));
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Controller with shared dependencies
+* class Database {
+*   getUsers() { return ["Alice", "Bob"]; }
+* }
+*
+* const usersController = controller((app, box) => {
+*   const db = box.get(Database);
+*   app.get("/", () => db.getUsers());
+* });
+* ```
+*/
+function controller(fn) {
+	return factory((box) => application(fn, box).app);
+}
+
+//#endregion
+export { application, controller };

package/package.json

@@ -1,22 +1,34 @@
 {
   "name": "serverstruct",
-  "version": "0.2.0",
-  "description": "Type safe and modular servers with Hono",
+  "version": "0.4.0",
+  "description": "Type safe and modular servers with H3",
   "private": false,
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
+  "scripts": {
+    "build": "tsc && tsdown src/index.ts --format esm,cjs",
+    "release": "pnpm run build && changeset publish",
+    "watch": "vitest",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
   "keywords": [
-    "hono",
+    "h3",
     "server",
-    "hollywood-di",
+    "DI",
     "typescript"
   ],
   "author": "Eric Afes <eriicafes@gmail.com>",
@@ -30,24 +42,15 @@
   },
   "homepage": "https://github.com/eriicafes/serverstruct#readme",
   "devDependencies": {
-    "@changesets/cli": "^2.26.2",
-    "@types/node": "^20.4.2",
-    "@vitest/coverage-v8": "^1.6.0",
-    "shx": "^0.3.4",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.6",
-    "vitest": "^1.6.0"
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "tsdown": "^0.18.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "hollywood-di": ">= 0.5.2",
-    "hono": ">= 4.0.0"
-  },
-  "scripts": {
-    "prebuild": "shx rm -rf dist",
-    "build": "tsc --noEmit && tsup src/index.ts --format esm,cjs --dts",
-    "release": "pnpm run build && changeset publish",
-    "watch": "vitest",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "getbox": ">= 0.2.0",
+    "h3": ">=2.0.1-rc.6 <3.0.0"
   }
 }

package/dist/index.d.ts

@@ -1,41 +0,0 @@
-import { AnyHollywood, HollywoodOf, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
-import { Env, Schema, Hono } from 'hono';
-import { BlankEnv, BlankSchema } from 'hono/types';
-
-type Merge<T, To> = T & Omit<To, keyof T>;
-type IsEmptyObject<T> = keyof T extends never ? true : false;
-type KnownKey<T> = string extends T ? never : number extends T ? never : symbol extends T ? never : T;
-type KnownMappedKeys<T> = {
-    [K in keyof T as KnownKey<K>]: T[K];
-} & {};
-
-type Subroute<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any>;
-};
-type Subroutes<TContainer extends Record<string, any> = any> = Record<string, Subroute<TContainer>>;
-type InferSubroutes<R extends Subroutes = {}> = {
-    [K in keyof R]: R[K] extends Route<any, infer App, any> ? App : never;
-} & {};
-declare class Route<Deps extends Record<string, any>, App extends Hono<any, any>, Routes extends Subroutes> {
-    private route;
-    private context;
-    constructor(route: (app: Hono<any, any>, container: any, routes: InferSubroutes<Routes>) => App, context: [
-        tokens: {
-            tokens: RegisterTokens<any, any>;
-            options?: ContainerOptions;
-        } | undefined,
-        routes: Subroutes<any>
-    ][]);
-    app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(container?: never): IsEmptyObject<Deps> extends true ? App : never;
-}
-declare class RouteBuilder<Deps extends Record<string, any>, Container extends AnyHollywood | undefined, E extends Env, S extends Schema, Routes extends Subroutes> {
-    private context;
-    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : RouteBuilder<T, HollywoodOf<T>, E, S, Routes>;
-    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): RouteBuilder<Deps, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>, E, S, Routes>;
-    subroutes<T extends Subroutes<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(routes: T): RouteBuilder<Deps, Container, E, S, Merge<T, Routes> extends infer T_1 ? { [K in keyof T_1]: Merge<T, Routes>[K]; } : never>;
-    route<App extends Hono<any, any>>(fn: (app: Hono<E, S>, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, routes: InferSubroutes<Routes>) => App): Route<Deps, App, Routes>;
-}
-declare function createRoute<E extends Env = BlankEnv>(): RouteBuilder<{}, undefined, E, BlankSchema, {}>;
-
-export { createRoute };

package/dist/index.js

@@ -1,93 +0,0 @@
-"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/index.ts
-var src_exports = {};
-__export(src_exports, {
-  createRoute: () => createRoute
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/route.ts
-var import_hollywood_di = require("hollywood-di");
-var import_hono = require("hono");
-var Route = class {
-  constructor(route, context) {
-    this.route = route;
-    this.context = context;
-  }
-  app(container) {
-    var _a;
-    let currentContainer = container;
-    const resolvedRoutes = {};
-    for (const [tokens, subroutes] of this.context) {
-      let subContainer = currentContainer;
-      if (tokens && subContainer) {
-        subContainer = import_hollywood_di.Hollywood.createWithParent(
-          subContainer,
-          tokens.tokens,
-          tokens.options
-        );
-      } else if (tokens) {
-        subContainer = import_hollywood_di.Hollywood.create(tokens.tokens, tokens.options);
-      }
-      currentContainer = subContainer;
-      for (const [key, subroute] of Object.entries(subroutes)) {
-        resolvedRoutes[key] = subroute.app(subContainer);
-      }
-    }
-    const instances = (_a = currentContainer == null ? void 0 : currentContainer.instances) != null ? _a : {};
-    return this.route(
-      new import_hono.Hono(),
-      instances,
-      resolvedRoutes
-    );
-  }
-};
-var RouteBuilder = class {
-  constructor() {
-    this.context = [];
-  }
-  use() {
-    return this;
-  }
-  provide(tokens, options) {
-    this.context.push([{ tokens, options }, {}]);
-    return this;
-  }
-  subroutes(routes) {
-    if (!this.context.length)
-      this.context.push([void 0, routes]);
-    else {
-      const [, subroutes] = this.context[this.context.length - 1];
-      Object.assign(subroutes, routes);
-    }
-    return this;
-  }
-  route(fn) {
-    return new Route(fn, this.context);
-  }
-};
-function createRoute() {
-  return new RouteBuilder();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createRoute
-});