@rexeus/typeweaver-server 0.5.1

package/dist/lib/TypedMiddleware.ts

@@ -0,0 +1,140 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+
+import type { IHttpResponse } from "@rexeus/typeweaver-core";
+import type { Middleware } from "./Middleware";
+import type { ServerContext } from "./ServerContext";
+import type { TypeweaverApp } from "./TypeweaverApp";
+
+/**
+ * A middleware descriptor carrying compile-time metadata about what state
+ * it provides to downstream consumers and what state it requires from
+ * upstream middleware.
+ *
+ * Created via {@link defineMiddleware}. The `_brand` property exists purely
+ * at the type level for TypeScript's inference — its runtime value is an empty object.
+ *
+ * @template TProvides - State keys this middleware adds to the context
+ * @template TRequires - State keys this middleware expects to already exist
+ */
+export type TypedMiddleware<
+  TProvides extends Record<string, unknown> = {},
+  TRequires extends Record<string, unknown> = {},
+> = {
+  readonly handler: Middleware;
+  readonly _brand: {
+    readonly provides: TProvides;
+    readonly requires: TRequires;
+  };
+};
+
+/**
+ * Compile-time error type produced when a typed middleware's requirements
+ * are not satisfied by the current accumulated app state.
+ *
+ * When intersected with `TypedMiddleware`, produces an uninhabitable type —
+ * no value can satisfy both, causing a clear compiler error at the call site.
+ *
+ * The error type's properties (`required`, `available`, `missing`) appear
+ * in the compiler diagnostic, helping developers identify what's wrong.
+ */
+export type StateRequirementError<
+  TRequired extends Record<string, unknown>,
+  TAvailable extends Record<string, unknown>,
+> = {
+  readonly __error: "STATE_REQUIREMENT_NOT_MET";
+  readonly required: TRequired;
+  readonly available: TAvailable;
+  readonly missing: Exclude<keyof TRequired, keyof TAvailable>;
+};
+
+/**
+ * The type of the `next` function inside a typed middleware handler.
+ *
+ * When `TProvides` has keys, `next` requires the state object as its argument,
+ * enforcing at compile time that middleware provides the state it declares.
+ *
+ * When `TProvides` is empty (`{}`), `next` takes no arguments — the middleware
+ * is pass-through and doesn't need to provide any state.
+ *
+ * @template TProvides - The state keys this middleware declares it provides
+ */
+export type NextFn<TProvides extends Record<string, unknown>> = [
+  keyof TProvides,
+] extends [never]
+  ? () => Promise<IHttpResponse>
+  : (state: TProvides) => Promise<IHttpResponse>;
+
+/**
+ * Creates a typed middleware descriptor.
+ *
+ * The handler receives a `ServerContext` parameterized with the required
+ * upstream state, and a `next` function that enforces providing the declared
+ * state. When the middleware declares `TProvides`, the state must be passed
+ * to `next()` — the pipeline merges it into `ctx.state` before continuing.
+ *
+ * @template TProvides - State keys this middleware adds
+ * @template TRequires - State keys this middleware expects (defaults to none)
+ *
+ * @example
+ * ```typescript
+ * // Middleware that provides state — MUST pass it to next()
+ * const auth = defineMiddleware<{ userId: string }>(async (ctx, next) => {
+ *   return next({ userId: parseToken(ctx.request.header?.["authorization"]) });
+ * });
+ *
+ * // Middleware with requirements — reads upstream state, provides new state
+ * const permissions = defineMiddleware<{ permissions: string[] }, { userId: string }>(
+ *   async (ctx, next) => {
+ *     const userId = ctx.state.get("userId"); // string (no undefined!)
+ *     return next({ permissions: await loadPermissions(userId) });
+ *   }
+ * );
+ *
+ * // Pass-through middleware — next() takes no args
+ * const logger = defineMiddleware(async (ctx, next) => {
+ *   console.log(ctx.request.path);
+ *   return next();
+ * });
+ * ```
+ */
+export function defineMiddleware<
+  TProvides extends Record<string, unknown> = {},
+  TRequires extends Record<string, unknown> = {},
+>(
+  handler: (
+    ctx: ServerContext<TRequires>,
+    next: NextFn<TProvides>
+  ) => Promise<IHttpResponse>
+): TypedMiddleware<TProvides, TRequires> {
+  return {
+    handler: handler as Middleware,
+    _brand: {} as TypedMiddleware<TProvides, TRequires>["_brand"],
+  };
+}
+
+/**
+ * Extracts the accumulated state type from a `TypeweaverApp` instance.
+ *
+ * Use this to derive the state type for handler implementations
+ * without declaring it separately.
+ *
+ * @example
+ * ```typescript
+ * const app = new TypeweaverApp()
+ *   .use(authMiddleware)
+ *   .use(permissionsMiddleware);
+ *
+ * type AppState = InferState<typeof app>;
+ * // { userId: string } & { permissions: string[] }
+ *
+ * const handlers: TodoApiHandler<AppState> = { ... };
+ * ```
+ */
+export type InferState<T> = T extends TypeweaverApp<infer S> ? S : never;

package/dist/lib/TypeweaverApp.ts

@@ -0,0 +1,376 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+import { HttpResponse, RequestValidationError } from "@rexeus/typeweaver-core";
+import type { IHttpResponse } from "@rexeus/typeweaver-core";
+import { BodyParseError, PayloadTooLargeError } from "./Errors";
+import { FetchApiAdapter } from "./FetchApiAdapter";
+import { executeMiddlewarePipeline } from "./Middleware";
+import { Router } from "./Router";
+import { StateMap } from "./StateMap";
+import type { Middleware } from "./Middleware";
+import type { RequestHandler } from "./RequestHandler";
+import type {
+  HttpResponseErrorHandler,
+  RouteDefinition,
+  UnknownErrorHandler,
+  ValidationErrorHandler,
+} from "./Router";
+import type { ServerContext } from "./ServerContext";
+import type { StateRequirementError, TypedMiddleware } from "./TypedMiddleware";
+import type { TypeweaverRouter } from "./TypeweaverRouter";
+
+/**
+ * The main application class that provides routing, middleware, and
+ * request handling — all using typeweaver's native `IHttpRequest`/`IHttpResponse` format.
+ *
+ * Exposes a single `fetch()` method compatible with Bun, Deno, Cloudflare Workers,
+ * and adaptable to Node.js `http.createServer`.
+ *
+ * Internally, the entire pipeline operates on `IHttpRequest`/`IHttpResponse`.
+ * Conversion from/to Fetch API `Request`/`Response` happens **only** at the boundary.
+ *
+ * Middleware is return-based: each middleware returns an `IHttpResponse`
+ * instead of mutating shared state.
+ *
+ * Middleware runs for **all** requests, including 404s and 405s, so global
+ * concerns like logging and CORS always execute.
+ *
+ * @example
+ * ```typescript
+ * const app = new TypeweaverApp()
+ *   .use(authMiddleware)       // defineMiddleware<{ userId: string }>
+ *   .use(permissionsMiddleware) // defineMiddleware<{ perms: string[] }, { userId: string }>
+ *   .route(new TodoRouter({ requestHandlers: { ... } }));
+ *
+ * Bun.serve({ fetch: app.fetch, port: 3000 });
+ * ```
+ */
+export type TypeweaverAppOptions = {
+  readonly maxBodySize?: number;
+  readonly onError?: (error: unknown) => void;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export class TypeweaverApp<TState extends Record<string, unknown> = {}> {
+  private static readonly INTERNAL_SERVER_ERROR_BODY = {
+    code: "INTERNAL_SERVER_ERROR",
+    message: "An unexpected error occurred",
+  } as const;
+
+  private readonly router = new Router();
+  private readonly middlewares: Middleware[] = [];
+  private readonly adapter: FetchApiAdapter;
+  private readonly onError: (error: unknown) => void;
+
+  public constructor(options?: TypeweaverAppOptions) {
+    this.adapter = new FetchApiAdapter({ maxBodySize: options?.maxBodySize });
+    this.onError = options?.onError ?? console.error;
+  }
+
+  private safeOnError(error: unknown): void {
+    try {
+      this.onError(error);
+    } catch (onErrorFailure) {
+      console.error(
+        "TypeweaverApp: onError callback threw while handling error",
+        { onErrorFailure, originalError: error }
+      );
+    }
+  }
+
+  /**
+   * Register a typed middleware that provides state to downstream handlers.
+   *
+   * Returns a new `TypeweaverApp` type with the accumulated state.
+   * Produces a compile-time error if the middleware's requirements are not met
+   * by the currently accumulated state.
+   *
+   * Use {@link defineMiddleware} to create typed middleware.
+   */
+  public use<
+    TProv extends Record<string, unknown>,
+    TReq extends Record<string, unknown>,
+  >(
+    middleware: TypedMiddleware<TProv, TReq> &
+      ([TState] extends [TReq] ? unknown : StateRequirementError<TReq, TState>)
+  ): TypeweaverApp<TState & TProv> {
+    this.middlewares.push(middleware.handler);
+    return this as unknown as TypeweaverApp<TState & TProv>;
+  }
+
+  /**
+   * Mount a generated `TypeweaverRouter` instance.
+   *
+   * Registers all routes from the router into the app.
+   * Multiple routers can be mounted on the same app.
+   *
+   * Optionally accepts a prefix to prepend to all routes from the router.
+   *
+   * @example
+   * ```typescript
+   * app.route(new AccountRouter({ requestHandlers: { ... } }));
+   * app.route("/api/v1", new TodoRouter({ requestHandlers: { ... } }));
+   * ```
+   */
+  public route(router: TypeweaverRouter<Record<string, RequestHandler>>): this;
+  public route(
+    prefix: string,
+    router: TypeweaverRouter<Record<string, RequestHandler>>
+  ): this;
+  public route(
+    prefixOrRouter: string | TypeweaverRouter<Record<string, RequestHandler>>,
+    router?: TypeweaverRouter<Record<string, RequestHandler>>
+  ): this {
+    if (typeof prefixOrRouter === "string") {
+      if (!router) {
+        throw new Error("Router is required when mounting with a prefix");
+      }
+      return this.mountRouter(router, prefixOrRouter);
+    }
+    return this.mountRouter(prefixOrRouter);
+  }
+
+  /**
+   * Universal request handler compatible with Fetch API runtimes.
+   *
+   * The entire pipeline works with `IHttpRequest`/`IHttpResponse`.
+   * Conversion from/to Fetch API `Request`/`Response` happens only here, at the boundary.
+   *
+   * Middleware runs for all requests (including 404s and 405s).
+   * HEAD requests automatically fall back to GET handlers with body stripped from the response.
+   *
+   * @example
+   * ```typescript
+   * // Bun
+   * Bun.serve({ fetch: app.fetch, port: 3000 });
+   *
+   * // Deno
+   * Deno.serve({ port: 3000 }, app.fetch);
+   * ```
+   */
+  public fetch = async (request: Request): Promise<Response> => {
+    try {
+      const response = await this.processRequest(request);
+      return this.adapter.toResponse(response);
+    } catch (error) {
+      if (error instanceof PayloadTooLargeError) {
+        this.safeOnError(error);
+        return this.adapter.toResponse({
+          statusCode: 413,
+          body: {
+            code: "PAYLOAD_TOO_LARGE",
+            message: "Request body exceeds the size limit",
+          },
+        });
+      }
+      if (error instanceof BodyParseError) {
+        return this.adapter.toResponse({
+          statusCode: 400,
+          body: { code: "BAD_REQUEST", message: "Malformed request body" },
+        });
+      }
+      this.safeOnError(error);
+      return TypeweaverApp.createErrorResponse();
+    }
+  };
+
+  private async processRequest(request: Request): Promise<IHttpResponse> {
+    const url = new URL(request.url);
+    const httpRequest = await this.adapter.toRequest(request, url);
+
+    const ctx: ServerContext = {
+      request: httpRequest,
+      state: new StateMap(),
+    };
+
+    const response = await executeMiddlewarePipeline(
+      this.middlewares,
+      ctx,
+      () => this.resolveAndExecute(request.method, url.pathname, ctx)
+    );
+
+    return request.method.toUpperCase() === "HEAD"
+      ? { ...response, body: undefined }
+      : response;
+  }
+
+  /**
+   * Match the route and execute the handler.
+   * Called as the final handler in the middleware pipeline.
+   */
+  private async resolveAndExecute(
+    method: string,
+    pathname: string,
+    ctx: ServerContext
+  ): Promise<IHttpResponse> {
+    const match = this.router.match(method, pathname);
+
+    if (match) {
+      const routeCtx = this.withPathParams(ctx, match.params);
+      try {
+        return await this.executeHandler(routeCtx, match.route);
+      } catch (error) {
+        return this.handleError(error, routeCtx, match.route);
+      }
+    }
+
+    const pathMatch = this.router.matchPath(pathname);
+    if (pathMatch) {
+      return {
+        statusCode: 405,
+        header: { Allow: pathMatch.allowedMethods.join(", ") },
+        body: {
+          code: "METHOD_NOT_ALLOWED",
+          message: "Method not supported for this resource",
+        },
+      };
+    }
+
+    return {
+      statusCode: 404,
+      body: { code: "NOT_FOUND", message: "No matching resource found" },
+    };
+  }
+
+  private withPathParams(
+    ctx: ServerContext,
+    params: Record<string, string>
+  ): ServerContext {
+    if (Object.keys(params).length === 0) return ctx;
+    return { ...ctx, request: { ...ctx.request, param: params } };
+  }
+
+  private async executeHandler(
+    ctx: ServerContext,
+    route: RouteDefinition
+  ): Promise<IHttpResponse> {
+    const validatedRequest = route.routerConfig.validateRequests
+      ? route.validator.validate(ctx.request)
+      : ctx.request;
+
+    return route.handler(validatedRequest, ctx);
+  }
+
+  /**
+   * Handle errors using the route's configured error handlers.
+   * Handler errors bubble up to the safety net in `fetch()`.
+   */
+  private handleError(
+    error: unknown,
+    ctx: ServerContext,
+    route: RouteDefinition
+  ): IHttpResponse | Promise<IHttpResponse> {
+    const config = route.routerConfig;
+
+    if (error instanceof RequestValidationError) {
+      const handler = this.resolveErrorHandler<ValidationErrorHandler>(
+        config.handleValidationErrors,
+        TypeweaverApp.defaultValidationHandler
+      );
+      if (handler) return handler(error, ctx);
+    }
+
+    if (error instanceof HttpResponse) {
+      const handler = this.resolveErrorHandler<HttpResponseErrorHandler>(
+        config.handleHttpResponseErrors,
+        TypeweaverApp.defaultHttpResponseHandler
+      );
+      if (handler) return handler(error, ctx);
+    }
+
+    const handler = this.resolveErrorHandler<UnknownErrorHandler>(
+      config.handleUnknownErrors,
+      this.defaultUnknownHandler
+    );
+    if (handler) return handler(error, ctx);
+
+    throw error;
+  }
+
+  /**
+   * Resolve an error handler option to a concrete handler function.
+   */
+  private resolveErrorHandler<T extends (...args: any[]) => any>(
+    option: T | boolean | undefined,
+    defaultHandler: T
+  ): T | undefined {
+    if (option === false) return undefined;
+    if (option === true || option === undefined) return defaultHandler;
+    return option;
+  }
+
+  private mountRouter(
+    router: TypeweaverRouter<Record<string, RequestHandler>>,
+    prefix?: string
+  ): this {
+    const normalizedPrefix = prefix?.replace(/\/+$/, "");
+    for (const route of router.getRoutes()) {
+      this.router.add({
+        ...route,
+        path: normalizedPrefix ? normalizedPrefix + route.path : route.path,
+      });
+    }
+    return this;
+  }
+
+  private static sanitizeIssues(
+    issues: readonly {
+      readonly message: string;
+      readonly path: PropertyKey[];
+    }[]
+  ): readonly { message: string; path: PropertyKey[] }[] | undefined {
+    if (issues.length === 0) return undefined;
+    return issues.map(({ message, path }) => ({ message, path }));
+  }
+
+  private static defaultValidationHandler: ValidationErrorHandler = (
+    err
+  ): IHttpResponse => {
+    const issues: Record<string, unknown> = Object.create(null);
+
+    const header = TypeweaverApp.sanitizeIssues(err.headerIssues);
+    const body = TypeweaverApp.sanitizeIssues(err.bodyIssues);
+    const query = TypeweaverApp.sanitizeIssues(err.queryIssues);
+    const param = TypeweaverApp.sanitizeIssues(err.pathParamIssues);
+
+    if (header) issues.header = header;
+    if (body) issues.body = body;
+    if (query) issues.query = query;
+    if (param) issues.param = param;
+
+    return {
+      statusCode: 400,
+      body: {
+        code: "VALIDATION_ERROR",
+        message: err.message,
+        issues,
+      },
+    };
+  };
+
+  private static defaultHttpResponseHandler: HttpResponseErrorHandler = (
+    err
+  ): IHttpResponse => err;
+
+  private readonly defaultUnknownHandler: UnknownErrorHandler = (
+    error
+  ): IHttpResponse => {
+    this.safeOnError(error);
+    return { statusCode: 500, body: TypeweaverApp.INTERNAL_SERVER_ERROR_BODY };
+  };
+
+  private static createErrorResponse(): Response {
+    return new Response(
+      JSON.stringify(TypeweaverApp.INTERNAL_SERVER_ERROR_BODY),
+      {
+        status: 500,
+        headers: { "content-type": "application/json" },
+      }
+    );
+  }
+}

package/dist/lib/TypeweaverRouter.ts

@@ -0,0 +1,138 @@
+// NOTE: The @generated header below is for the copy that ships to user projects.
+// This file IS the source of truth — edit it here.
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+import type { HttpMethod, IRequestValidator } from "@rexeus/typeweaver-core";
+import type { RequestHandler } from "./RequestHandler";
+import type {
+  HttpResponseErrorHandler,
+  RouteDefinition,
+  RouterErrorConfig,
+  UnknownErrorHandler,
+  ValidationErrorHandler,
+} from "./Router";
+
+/**
+ * Configuration options for TypeweaverRouter instances.
+ *
+ * @template RequestHandlers - Object type containing all handler methods for this router
+ */
+export type TypeweaverRouterOptions<
+  RequestHandlers extends Record<string, RequestHandler>,
+> = {
+  /**
+   * Request handler methods for each operation.
+   * Each handler receives a validated request and the server context.
+   */
+  readonly requestHandlers: RequestHandlers;
+
+  /**
+   * Enable request validation using generated validators.
+   * When false, requests are passed through without validation.
+   * @default true
+   */
+  readonly validateRequests?: boolean;
+
+  /**
+   * Configure handling of HttpResponse errors thrown by handlers.
+   * - `true`: Use default handler (returns the error as response)
+   * - `false`: Disable this handler (errors fall through to the unknown error handler)
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  readonly handleHttpResponseErrors?: HttpResponseErrorHandler | boolean;
+
+  /**
+   * Configure handling of request validation errors.
+   * - `true`: Use default handler (400 with error details)
+   * - `false`: Disable this handler (errors fall through to the unknown error handler)
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  readonly handleValidationErrors?: ValidationErrorHandler | boolean;
+
+  /**
+   * Configure handling of unknown errors.
+   * - `true`: Use default handler (500 Internal Server Error)
+   * - `false`: Disable this handler (errors bubble up to the safety net)
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  readonly handleUnknownErrors?: UnknownErrorHandler | boolean;
+};
+
+/**
+ * Abstract base class for typeweaver-generated routers.
+ *
+ * Each generated router (e.g., `AccountRouter`, `TodoRouter`) extends this class
+ * and registers its routes in the constructor via `this.route(...)`.
+ *
+ * The router does **not** handle HTTP directly — it collects route definitions
+ * that are mounted onto a `TypeweaverApp` via `app.route(...)`.
+ *
+ * All types are in typeweaver's native `IHttpRequest`/`IHttpResponse` format.
+ * No framework-specific types are involved.
+ *
+ * @template RequestHandlers - Object type containing typed handler methods
+ */
+export abstract class TypeweaverRouter<
+  RequestHandlers extends Record<string, RequestHandler>,
+> {
+  protected readonly requestHandlers: RequestHandlers;
+  private readonly routes: RouteDefinition[] = [];
+  private readonly errorConfig: RouterErrorConfig;
+
+  public constructor(options: TypeweaverRouterOptions<RequestHandlers>) {
+    const {
+      requestHandlers,
+      validateRequests = true,
+      handleHttpResponseErrors = true,
+      handleValidationErrors = true,
+      handleUnknownErrors = true,
+    } = options;
+
+    this.requestHandlers = requestHandlers;
+
+    this.errorConfig = {
+      validateRequests,
+      handleHttpResponseErrors,
+      handleValidationErrors,
+      handleUnknownErrors,
+    };
+  }
+
+  /**
+   * Register a route. Called by generated subclasses in their constructor.
+   *
+   * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
+   * @param path - Path pattern with `:param` placeholders
+   * @param validator - Request validator for this operation
+   * @param handler - Type-safe request handler
+   */
+  protected route(
+    method: HttpMethod,
+    path: string,
+    validator: IRequestValidator,
+    handler: RequestHandler
+  ): void {
+    this.routes.push({
+      method,
+      path,
+      validator,
+      handler,
+      routerConfig: this.errorConfig,
+    });
+  }
+
+  /**
+   * Returns all registered routes. Used by `TypeweaverApp` when mounting via `app.route(...)`.
+   */
+  public getRoutes(): readonly RouteDefinition[] {
+    return this.routes;
+  }
+}

package/dist/lib/index.ts

@@ -0,0 +1,38 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+/* eslint-disable import/max-dependencies */
+
+export { TypeweaverApp, type TypeweaverAppOptions } from "./TypeweaverApp";
+export {
+  TypeweaverRouter,
+  type TypeweaverRouterOptions,
+} from "./TypeweaverRouter";
+export { HttpMethod } from "@rexeus/typeweaver-core";
+export type {
+  HttpResponseErrorHandler,
+  UnknownErrorHandler,
+  ValidationErrorHandler,
+} from "./Router";
+export type { ServerContext } from "./ServerContext";
+export type { RequestHandler } from "./RequestHandler";
+export { StateMap } from "./StateMap";
+export {
+  defineMiddleware,
+  type InferState,
+  type NextFn,
+  type StateRequirementError,
+  type TypedMiddleware,
+} from "./TypedMiddleware";
+export {
+  BodyParseError,
+  PayloadTooLargeError,
+  ResponseSerializationError,
+} from "./Errors";
+export { FetchApiAdapter } from "./FetchApiAdapter";
+export { nodeAdapter, type NodeAdapterOptions } from "./NodeAdapter";
+export { pathMatcher } from "./PathMatcher";

package/dist/metafile-cjs.json

@@ -0,0 +1 @@
+{"inputs":{"../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js":{"bytes":569,"imports":[],"format":"esm"},"src/RouterGenerator.ts":{"bytes":3869,"imports":[{"path":"node:path","kind":"import-statement","external":true},{"path":"node:url","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-core","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-gen","kind":"import-statement","external":true},{"path":"case","kind":"import-statement","external":true},{"path":"/Users/denniswentzien/Development/rexeus/typeweaver-5/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":1036,"imports":[{"path":"node:path","kind":"import-statement","external":true},{"path":"node:url","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-gen","kind":"import-statement","external":true},{"path":"src/RouterGenerator.ts","kind":"import-statement","original":"./RouterGenerator"},{"path":"/Users/denniswentzien/Development/rexeus/typeweaver-5/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"dist/index.cjs":{"imports":[{"path":"node:path","kind":"import-statement","external":true},{"path":"node:url","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-gen","kind":"import-statement","external":true},{"path":"node:path","kind":"import-statement","external":true},{"path":"node:url","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-core","kind":"import-statement","external":true},{"path":"@rexeus/typeweaver-gen","kind":"import-statement","external":true},{"path":"case","kind":"import-statement","external":true}],"exports":["default"],"entryPoint":"src/index.ts","inputs":{"../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js":{"bytesInOutput":314},"src/index.ts":{"bytesInOutput":583},"src/RouterGenerator.ts":{"bytesInOutput":2862}},"bytes":3988}}}