@warlock.js/core 5.30.0 → 5.32.0

package/esm/router/types.d.mts

@@ -2,33 +2,33 @@ import { RequestLoggingOptions } from "../http/request-log-snapshot.mjs";
 import { Response } from "../http/response.mjs";
 import { Request } from "../http/request.mjs";
 import { ReturnedResponse } from "../http/types.mjs";
+import "../http/index.mjs";
 import { ResponseSchema } from "../resource/types.mjs";
-import { ObjectValidator } from "@warlock.js/seal";
+import { ObjectValidator, ValidationResult } from "@warlock.js/seal";
 import { GenericObject } from "@mongez/reinforcements";
 import { RouteShorthandOptions } from "fastify";
-
 //#region ../../packages/core/src/router/types.d.ts
 /**
  * Middleware response
  */
-type MiddlewareResponse = ReturnedResponse | undefined | void;
+export type MiddlewareResponse = ReturnedResponse | undefined | void;
 /**
  * Middleware method
  * Receives the single context object (`{ request, response }`), same calling
  * convention as `RequestHandler`, and returns a response object or undefined
  * if the request should continue
  */
-type Middleware<MiddlewareRequest extends Request = Request> = {
+export type Middleware<MiddlewareRequest extends Request = Request> = {
   (context: HttpContext<MiddlewareRequest>): MiddlewareResponse;
 };
-type RouterGroupCallback = () => void;
-type RequestHandlerType = RequestHandler<any> | [GenericObject, string];
+export type RouterGroupCallback = () => void;
+export type RequestHandlerType = RequestHandler<any> | [GenericObject, string];
 /**
  * Resource standard methods
  */
-type ResourceMethod = "list" | "get" | "create" | "update" | "delete" | "patch";
-type RestfulMiddleware = Record<string, [Middleware]>;
-type RequestHandlerValidation<TRequest extends Request = Request> = {
+export type ResourceMethod = "list" | "get" | "create" | "update" | "delete" | "patch";
+export type RestfulMiddleware = Record<string, [Middleware]>;
+export type RequestHandlerValidation<TRequest extends Request = Request> = {
   /**
    * Validation custom message
    */
@@ -51,8 +51,55 @@ type RequestHandlerValidation<TRequest extends Request = Request> = {
    * schema expose their raw string params.
    */
   params?: ObjectValidator;
+  /**
+   * Shape the response when `schema` or `params` fails, instead of the
+   * framework's `{ errors: [...] }` body.
+   *
+   * Return `{ status?, body }`: `body` is sent as the response, with `status`
+   * or else `validation.response.status` (422 by default). Return `undefined`
+   * to fall back to the global `validation.response.body` hook, then the
+   * framework body. Wins over the global hook.
+   *
+   * Declare the body in the handler's `responseSchema` under the same status
+   * so `warlock generate.openapi` documents it.
+   *
+   * @example
+   * createImportController.validation = {
+   *   schema: importSchema,
+   *   onFailure: () => ({ status: 400, body: { error: "IMPORT_REQUEST_INVALID" } }),
+   * };
+   */
+  onFailure?: ValidationFailureHandler<TRequest>;
 };
-interface RequestControllerContract {
+/**
+ * What a validation failure hook answers with.
+ */
+export type ValidationFailureResponse = {
+  /**
+   * Response status. Defaults to `validation.response.status` (422).
+   */
+  status?: number;
+  /**
+   * Response body, sent as JSON.
+   */
+  body: unknown;
+};
+/**
+ * The second argument of a route's `validation.onFailure`.
+ */
+export type ValidationFailureContext<TRequest extends Request = Request> = {
+  request: TRequest;
+  response: Response;
+  /**
+   * The route whose validation failed.
+   */
+  route: Route;
+};
+/**
+ * A route's `validation.onFailure` hook.
+ */
+export type ValidationFailureHandler<TRequest extends Request = Request> = (result: ValidationResult, context: ValidationFailureContext<TRequest>) => ValidationFailureResponse | undefined | void | Promise<ValidationFailureResponse | undefined | void>;
+export interface RequestControllerContract {
   /**
    * Request object
    */
@@ -81,7 +128,7 @@ interface RequestControllerContract {
  * parameter, destructured at the call site, replacing the v4 positional
  * `(request, response)` pair.
  */
-type HttpContext<TRequest extends Request = Request> = {
+export type HttpContext<TRequest extends Request = Request> = {
   /**
    * Request object
    */
@@ -91,7 +138,7 @@ type HttpContext<TRequest extends Request = Request> = {
    */
   response: Response;
 };
-type RequestHandler<TRequest extends Request = Request> = {
+export type RequestHandler<TRequest extends Request = Request> = {
   /**
    * Function Declaration
    */
@@ -110,7 +157,38 @@ type RequestHandler<TRequest extends Request = Request> = {
    */
   responseSchema?: ResponseSchema;
 };
-interface RouteOptions {
+/**
+ * A route's own rate limit: its own bucket and quota instead of the global
+ * `http.rateLimit` policy.
+ */
+export type RouteRateLimitOptions = {
+  /**
+   * Max number of requests within the time window
+   */
+  max: number;
+  /**
+   * Time window in milliseconds
+   */
+  timeWindow: number;
+  /**
+   * Error message when rate limit is exceeded
+   */
+  errorMessage?: string;
+};
+/**
+ * Options for a static mount: `router.directory()`, `router.file()`,
+ * `router.cachedFile()`, `router.files()` and `router.cachedFiles()`.
+ */
+export type StaticMountOptions = {
+  /**
+   * How the rate limiter treats this mount. Leave it unset to follow
+   * `http.rateLimit.staticFiles` (exempt by default); `true` counts the
+   * mount against the global limiter, `false` exempts it, and an object
+   * gives it its own limit and bucket.
+   */
+  rateLimit?: RouteRateLimitOptions | boolean;
+};
+export interface RouteOptions {
   /**
    * Route middleware
    */
@@ -170,22 +248,21 @@ interface RouteOptions {
    */
   isPage?: boolean;
   /**
-   * Rate limit options for this route
+   * How the rate limiter treats this route.
+   *
+   * - an object: the route gets its own limit and bucket instead of the
+   *   global `http.rateLimit` policy;
+   * - `false`: the route is exempt from the global limiter (development and
+   *   production alike);
+   * - `true`: the route stays under the global limiter. This is the default
+   *   for application routes; it puts a `router.file()` route back under the
+   *   global limiter when static files are exempt.
+   *
+   * @example
+   * router.post("/login", login, { rateLimit: { max: 5, timeWindow: 60_000 } });
+   * router.get("/webhooks/status", status, { rateLimit: false });
    */
-  rateLimit?: {
-    /**
-     * Max number of requests within the time window
-     */
-    max: number;
-    /**
-     * Time window in milliseconds
-     */
-    timeWindow: number;
-    /**
-     * Error message when rate limit is exceeded
-     */
-    errorMessage?: string;
-  };
+  rateLimit?: RouteRateLimitOptions | boolean;
   /**
    * Opt this route OUT of the default core CSRF-Origin guard
    * (`../http/csrf-default-guard.ts`, SECURITY card 8a752ab2) by passing
@@ -209,6 +286,20 @@ interface RouteOptions {
    * router.post("/oauth/callback", handler, { csrf: false });
    */
   csrf?: false;
+  /**
+   * Route-level validation, merged over the handler's own `validation`
+   * (keys set here win). Lets one handler serve several routes with different
+   * schemas or failure responses.
+   *
+   * @example
+   * router.post("/workspace-import", importWorkspace, {
+   *   validation: {
+   *     schema: importWorkspaceSchema,
+   *     onFailure: () => ({ status: 400, body: { error: "IMPORT_REQUEST_INVALID" } }),
+   *   },
+   * });
+   */
+  validation?: RequestHandlerValidation;
   /**
    * What this route's request log entries carry of its input, overriding
    * `http.logging`. Applied before any entry is built, so an omitted body or
@@ -220,10 +311,22 @@ interface RouteOptions {
    * });
    */
   logging?: RequestLoggingOptions;
+  /**
+   * Declare a mutating route (POST/PUT/PATCH/DELETE) intentionally reachable
+   * without signing in — a login, a webhook, a contact form. It changes
+   * nothing at runtime; it records the decision so `warlock dev` and
+   * `warlock check` (`WL9006`) stop reporting that the route has no auth
+   * middleware. A group's `public: true` applies to every route
+   * registered inside it. `warlock make endpoint --public` writes it.
+   *
+   * @example
+   * router.post("/auth/login", loginController, { public: true });
+   */
+  public?: boolean;
 }
-type RequestMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "all";
+export type RequestMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "all";
 /** Browser-safe snapshot metadata for a named application API route. */
-type NamedApiRoute = Readonly<{
+export type NamedApiRoute = Readonly<{
   name: string;
   path: string;
   method: RequestMethod;
@@ -236,7 +339,7 @@ type NamedApiRoute = Readonly<{
   response?: Readonly<Record<string, string>>;
 }>;
 /** Options for `router.getNamedApiRoutes()`. */
-type NamedApiRoutesOptions = Readonly<{
+export type NamedApiRoutesOptions = Readonly<{
   /**
    * Describe the response types of a route that declares `responseSchema`.
    * Returning `undefined` (or an empty record) leaves the route without a `response` key.
@@ -246,7 +349,7 @@ type NamedApiRoutesOptions = Readonly<{
 /**
  * Route Object
  */
-type Route = RouteOptions & {
+export type Route = RouteOptions & {
   /**
    * Route method
    */
@@ -280,12 +383,18 @@ type Route = RouteOptions & {
    * Rate limit
    */
   rateLimit?: RouteOptions["rateLimit"];
+  /**
+   * Set by `router.file()`, `router.cachedFile()`, `router.files()` and
+   * `router.cachedFiles()`: the route serves a static file, so it follows
+   * `http.rateLimit.staticFiles` unless it sets `rateLimit` itself.
+   */
+  $staticFile?: boolean;
 };
-type PartialPick<T, F extends keyof T> = Omit<T, F> & Partial<Pick<T, F>>;
+export type PartialPick<T, F extends keyof T> = Omit<T, F> & Partial<Pick<T, F>>;
 /**
  * Grouped routes options
  */
-type GroupedRoutesOptions = {
+export type GroupedRoutesOptions = {
   /**
    * Middlewares to be applied to all routes
    */
@@ -299,9 +408,15 @@ type GroupedRoutesOptions = {
    * This will be added to each route as a name prefix
    */
   name?: string;
+  /**
+   * Mark every route in the group as intentionally reachable without
+   * signing in (see `RouteOptions.public`). A route's own `public: false`
+   * opts it back out.
+   */
+  public?: boolean;
 };
 /** Route resource */
-type RouteResource = {
+export type RouteResource = {
   /**
    * list route
    */
@@ -352,15 +467,19 @@ type RouteResource = {
     patch?: RequestHandlerValidation<any>;
   };
 };
-type RouterStacks = {
+export type RouterStacks = {
   prefix: string[];
   name: string[];
   middleware: Middleware[];
+  /**
+   * Open `router.group({ public: true })` scopes; routes registered while any
+   * is open default to `public: true`.
+   */
+  public?: number;
   /**
    * Source file path for routes being added (for HMR route tracking)
    */
   sourceFile?: string;
 };
 //#endregion
-export { GroupedRoutesOptions, HttpContext, Middleware, MiddlewareResponse, NamedApiRoute, NamedApiRoutesOptions, PartialPick, RequestControllerContract, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestMethod, ResourceMethod, RestfulMiddleware, Route, RouteOptions, RouteResource, RouterGroupCallback, RouterStacks };
 //# sourceMappingURL=types.d.mts.map

package/esm/router/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/router/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/router/types.ts"],"mappings":";;;;;;;;;;;;;YAUY,qBAAqB;;;;;;;YAQrB,WAAW,0BAA0B,UAAU;GACxD,SAAS,YAAY,qBAAqB;;YAGjC;YAEA,qBAAqB,uBAAuB;;;;YAK5C;YAEA,oBAAoB,gBAAgB;YAEpC,yBAAyB,iBAAiB,UAAU;;;;EAI9D,WAAW,WAAW;;;;;;EAMtB;;;;EAIA,SAAS;;;;;;;;EAQT,SAAS;;;;;;;;;;;;;;;;;;;EAmBT,YAAY,yBAAyB;;;;;YAM3B;;;;EAIV;;;;EAIA;;;;;YAMU,yBAAyB,iBAAiB,UAAU;EAC9D,SAAS;EACT,UAAU;;;;EAIV,OAAO;;;;;YAMG,yBAAyB,iBAAiB,UAAU,YAC9D,QAAQ,kBACR,SAAS,yBAAyB,cAEhC,+CAGA,QAAQ;iBAEK;;;;EAIf,SAAS;;;;EAIT,UAAU;;;;EAIV,WAAW,QAAQ;;;;EAInB;;;;EAIA,mBAAmB,QAAQ,sBAAsB;;;;;;;;;YAUvC,YAAY,iBAAiB,UAAU;;;;EAIjD,SAAS;;;;EAIT,UAAU;;YAGA,eAAe,iBAAiB,UAAU;;;;GAInD,SAAS,YAAY,YAAY;;;;EAKlC,aAAa,yBAAyB;;;;EAKtC;;;;;EAMA,iBAAiB;;;;;;YAOP;;;;EAIV;;;;EAIA;;;;EAIA;;;;;;YAOU;;;;;;;EAOV,YAAY;;iBAGG;;;;EAIf,aAAa;;;;EAIb;;;;EAIA;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA,gBAAgB;;;;;;EAMhB;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;;EAgBA,YAAY;;;;;;;;;;;;;;;;;;;;;;;EAuBZ;;;;;;;;;;;;;;EAcA,aAAa;;;;;;;;;;;EAWb,UAAU;;;;;;;;;;;;EAYV;;YAGU;;YAWA,gBAAgB;EAC1B;EACA;EACA,QAAQ;;;;;;;EAOR,WAAW,SAAS;;;YAIV,wBAAwB;;;;;EAKlC,mBACE,QAAQ,gBACR,OAAO,UACJ,SAAS;;;;;YAMJ,QAAQ;;;;EAIlB,QAAQ;;;;EAIR;;;;EAIA;;;;;EAKA,SAAS;;;;;;EAMT;;;;;;EAMA;;;;EAIA,YAAY;;;;;;EAMZ;;YAGU,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;;;YAKjE;;;;EAIV,aAAa;;;;EAIb;;;;;EAKA;;;;;;EAMA;;;YAIU;;;;EAIV,OAAO;;;;EAIP,MAAM;;;;EAIN,SAAS;;;;EAIT,SAAS;;;;EAIT,QAAQ;;;;EAIR,SAAS;;;;EAIT,aAAa;;;;EAIb;;;;IAIE,MAAM;;;;IAIN,SAAS;;;;IAIT,SAAS;;;;IAIT,QAAQ;;;YAIA;EACV;EACA;EACA,YAAY;;;;;EAKZ;;;;EAIA"}

package/esm/router/unguarded-route-diagnostics.d.mts

@@ -0,0 +1,38 @@
+import { Route } from "./types.mjs";
+import { log } from "@warlock.js/logger";
+//#region ../../packages/core/src/router/unguarded-route-diagnostics.d.ts
+/**
+ * Marks a middleware as an authentication guard. A registry symbol, so a copy
+ * of core loaded twice (a linked package next to an installed one) still
+ * recognises guards the other copy marked.
+ */
+export declare const AUTH_GUARD_MARKER: unique symbol;
+/**
+ * Declare whether a middleware authenticates the request. `authMiddleware()`
+ * from `@warlock.js/auth` marks itself (and marks `{ optional: true }` as not
+ * a guard); use this for a hand-written guard whose name does not contain
+ * `auth` or `guard`.
+ *
+ * @example
+ * export const requireApiKey = markAuthGuard(async ({ request, response }) => {
+ *   if (request.headers["x-api-key"] !== env("API_KEY")) return response.unauthorized();
+ * });
+ */
+export declare function markAuthGuard<T extends (...args: never[]) => unknown>(middleware: T, isGuard?: boolean): T;
+/**
+ * Whether a middleware authenticates the request: its {@link markAuthGuard}
+ * marker when it has one, otherwise a function name containing `auth` or
+ * `guard`.
+ */
+export declare function isAuthGuardMiddleware(middleware: unknown): boolean;
+/** Whether a route mutates state, is not a page route, and is neither guarded nor public. */
+export declare function isUnguardedMutatingRoute(route: Route): boolean;
+/**
+ * Warn, once per route per process, about every mutating route with no auth
+ * middleware and no `public: true`. Returns the routes it reported.
+ */
+export declare function reportUnguardedMutatingRoutes(routes: readonly Route[], logger?: Pick<typeof log, "warn">): Route[];
+/** Forget what was reported (tests). */
+export declare function resetUnguardedRouteReports(): void;
+//#endregion
+//# sourceMappingURL=unguarded-route-diagnostics.d.mts.map

package/esm/router/unguarded-route-diagnostics.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unguarded-route-diagnostics.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/router/unguarded-route-diagnostics.ts"],"mappings":";;;;;;;;qBAuBa;;;;;;;;;;;;wBAaG,cAAc,cAAc,2BAC1C,YAAY,GACZ,oBACC;;;;;;wBAea,sBAAsB;;wBAUtB,yBAAyB,OAAO;;;;;wBAoBhC,8BACd,iBAAiB,SACjB,SAAQ,YAAY,eACnB;;wBAsCa"}

package/esm/router/unguarded-route-diagnostics.mjs

@@ -0,0 +1,95 @@
+import { isAuthGuardName, isMutatingHttpMethod } from "./route-guard-names.mjs";
+import { log } from "@warlock.js/logger";
+
+//#region ../../packages/core/src/router/unguarded-route-diagnostics.ts
+/**
+* Development warning for mutating routes that nobody guarded.
+*
+* A POST/PUT/PATCH/DELETE route without auth middleware is reachable by anyone
+* who can reach the server. Sometimes that is the point (a login, a webhook, a
+* contact form) and sometimes it is a forgotten `guarded()` block. The router
+* cannot tell the two apart, so the app says which with `public: true`, and
+* `warlock dev` lists every mutating route that has neither.
+*
+* Warning only: routes register and behave exactly as before, nothing here
+* throws, and production never runs it. `warlock check` reports the same
+* routes from source as `WL9006`, before the app runs.
+*/
+/**
+* Marks a middleware as an authentication guard. A registry symbol, so a copy
+* of core loaded twice (a linked package next to an installed one) still
+* recognises guards the other copy marked.
+*/
+const AUTH_GUARD_MARKER = Symbol.for("warlock.js.authGuard");
+/**
+* Declare whether a middleware authenticates the request. `authMiddleware()`
+* from `@warlock.js/auth` marks itself (and marks `{ optional: true }` as not
+* a guard); use this for a hand-written guard whose name does not contain
+* `auth` or `guard`.
+*
+* @example
+* export const requireApiKey = markAuthGuard(async ({ request, response }) => {
+*   if (request.headers["x-api-key"] !== env("API_KEY")) return response.unauthorized();
+* });
+*/
+function markAuthGuard(middleware, isGuard = true) {
+	Object.defineProperty(middleware, AUTH_GUARD_MARKER, {
+		value: isGuard,
+		configurable: true,
+		enumerable: false
+	});
+	return middleware;
+}
+/**
+* Whether a middleware authenticates the request: its {@link markAuthGuard}
+* marker when it has one, otherwise a function name containing `auth` or
+* `guard`.
+*/
+function isAuthGuardMiddleware(middleware) {
+	if (typeof middleware !== "function") return false;
+	const marker = Reflect.get(middleware, AUTH_GUARD_MARKER);
+	if (typeof marker === "boolean") return marker;
+	return isAuthGuardName(middleware.name);
+}
+/** Whether a route mutates state, is not a page route, and is neither guarded nor public. */
+function isUnguardedMutatingRoute(route) {
+	if (!isMutatingHttpMethod(String(route.method))) return false;
+	if (route.isPage) return false;
+	if (route.public === true) return false;
+	return !(route.middleware ?? []).some(isAuthGuardMiddleware);
+}
+/** Routes already reported in this process, so an HMR reload does not repeat them. */
+const reported = /* @__PURE__ */ new Set();
+function routeKey(route) {
+	return `${String(route.method).toUpperCase()} ${route.path}`;
+}
+/**
+* Warn, once per route per process, about every mutating route with no auth
+* middleware and no `public: true`. Returns the routes it reported.
+*/
+function reportUnguardedMutatingRoutes(routes, logger = log) {
+	const fresh = routes.filter((route) => isUnguardedMutatingRoute(route) && !reported.has(routeKey(route)));
+	if (fresh.length === 0) return fresh;
+	for (const route of fresh) reported.add(routeKey(route));
+	const headline = fresh.length === 1 ? "1 mutating route has no auth middleware and is not marked public." : `${fresh.length} mutating routes have no auth middleware and are not marked public.`;
+	logger.warn({
+		module: "router",
+		action: "unguardedRoute",
+		message: `${headline} Anyone who can reach the server can call them. Add auth middleware (e.g. register them inside a guarded group), or pass { public: true } if they are meant to be open:\n` + fresh.map((route) => `  - ${routeKey(route)}${route.sourceFile ? ` (${route.sourceFile})` : ""}`).join("\n"),
+		context: { routes: fresh.map((route) => ({
+			method: route.method,
+			path: route.path,
+			name: route.name,
+			sourceFile: route.sourceFile
+		})) }
+	});
+	return fresh;
+}
+/** Forget what was reported (tests). */
+function resetUnguardedRouteReports() {
+	reported.clear();
+}
+
+//#endregion
+export { AUTH_GUARD_MARKER, isAuthGuardMiddleware, isUnguardedMutatingRoute, markAuthGuard, reportUnguardedMutatingRoutes, resetUnguardedRouteReports };
+//# sourceMappingURL=unguarded-route-diagnostics.mjs.map

package/esm/router/unguarded-route-diagnostics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unguarded-route-diagnostics.mjs","names":[],"sources":["../../../../../../../../packages/core/src/router/unguarded-route-diagnostics.ts"],"sourcesContent":["/**\n * Development warning for mutating routes that nobody guarded.\n *\n * A POST/PUT/PATCH/DELETE route without auth middleware is reachable by anyone\n * who can reach the server. Sometimes that is the point (a login, a webhook, a\n * contact form) and sometimes it is a forgotten `guarded()` block. The router\n * cannot tell the two apart, so the app says which with `public: true`, and\n * `warlock dev` lists every mutating route that has neither.\n *\n * Warning only: routes register and behave exactly as before, nothing here\n * throws, and production never runs it. `warlock check` reports the same\n * routes from source as `WL9006`, before the app runs.\n */\n\nimport { log } from \"@warlock.js/logger\";\nimport { isAuthGuardName, isMutatingHttpMethod } from \"./route-guard-names\";\nimport type { Route } from \"./types\";\n\n/**\n * Marks a middleware as an authentication guard. A registry symbol, so a copy\n * of core loaded twice (a linked package next to an installed one) still\n * recognises guards the other copy marked.\n */\nexport const AUTH_GUARD_MARKER: unique symbol = Symbol.for(\"warlock.js.authGuard\");\n\n/**\n * Declare whether a middleware authenticates the request. `authMiddleware()`\n * from `@warlock.js/auth` marks itself (and marks `{ optional: true }` as not\n * a guard); use this for a hand-written guard whose name does not contain\n * `auth` or `guard`.\n *\n * @example\n * export const requireApiKey = markAuthGuard(async ({ request, response }) => {\n *   if (request.headers[\"x-api-key\"] !== env(\"API_KEY\")) return response.unauthorized();\n * });\n */\nexport function markAuthGuard<T extends (...args: never[]) => unknown>(\n  middleware: T,\n  isGuard = true,\n): T {\n  Object.defineProperty(middleware, AUTH_GUARD_MARKER, {\n    value: isGuard,\n    configurable: true,\n    enumerable: false,\n  });\n\n  return middleware;\n}\n\n/**\n * Whether a middleware authenticates the request: its {@link markAuthGuard}\n * marker when it has one, otherwise a function name containing `auth` or\n * `guard`.\n */\nexport function isAuthGuardMiddleware(middleware: unknown): boolean {\n  if (typeof middleware !== \"function\") return false;\n\n  const marker: unknown = Reflect.get(middleware, AUTH_GUARD_MARKER);\n  if (typeof marker === \"boolean\") return marker;\n\n  return isAuthGuardName(middleware.name);\n}\n\n/** Whether a route mutates state, is not a page route, and is neither guarded nor public. */\nexport function isUnguardedMutatingRoute(route: Route): boolean {\n  if (!isMutatingHttpMethod(String(route.method))) return false;\n  // Page actions are authorized by the page itself (`requireUser()`).\n  if (route.isPage) return false;\n  if (route.public === true) return false;\n\n  return !(route.middleware ?? []).some(isAuthGuardMiddleware);\n}\n\n/** Routes already reported in this process, so an HMR reload does not repeat them. */\nconst reported = new Set<string>();\n\nfunction routeKey(route: Route): string {\n  return `${String(route.method).toUpperCase()} ${route.path}`;\n}\n\n/**\n * Warn, once per route per process, about every mutating route with no auth\n * middleware and no `public: true`. Returns the routes it reported.\n */\nexport function reportUnguardedMutatingRoutes(\n  routes: readonly Route[],\n  logger: Pick<typeof log, \"warn\"> = log,\n): Route[] {\n  const fresh = routes.filter(\n    (route) => isUnguardedMutatingRoute(route) && !reported.has(routeKey(route)),\n  );\n\n  if (fresh.length === 0) return fresh;\n\n  for (const route of fresh) reported.add(routeKey(route));\n\n  const headline =\n    fresh.length === 1\n      ? \"1 mutating route has no auth middleware and is not marked public.\"\n      : `${fresh.length} mutating routes have no auth middleware and are not marked public.`;\n\n  logger.warn({\n    module: \"router\",\n    action: \"unguardedRoute\",\n    message:\n      `${headline} Anyone who can reach the server can call them. Add auth middleware ` +\n      `(e.g. register them inside a guarded group), or pass { public: true } if they are ` +\n      `meant to be open:\\n` +\n      fresh\n        .map((route) => `  - ${routeKey(route)}${route.sourceFile ? ` (${route.sourceFile})` : \"\"}`)\n        .join(\"\\n\"),\n    context: {\n      routes: fresh.map((route) => ({\n        method: route.method,\n        path: route.path,\n        name: route.name,\n        sourceFile: route.sourceFile,\n      })),\n    },\n  });\n\n  return fresh;\n}\n\n/** Forget what was reported (tests). */\nexport function resetUnguardedRouteReports(): void {\n  reported.clear();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,oBAAmC,OAAO,IAAI,sBAAsB;;;;;;;;;;;;AAajF,SAAgB,cACd,YACA,UAAU,MACP;CACH,OAAO,eAAe,YAAY,mBAAmB;EACnD,OAAO;EACP,cAAc;EACd,YAAY;CACd,CAAC;CAED,OAAO;AACT;;;;;;AAOA,SAAgB,sBAAsB,YAA8B;CAClE,IAAI,OAAO,eAAe,YAAY,OAAO;CAE7C,MAAM,SAAkB,QAAQ,IAAI,YAAY,iBAAiB;CACjE,IAAI,OAAO,WAAW,WAAW,OAAO;CAExC,OAAO,gBAAgB,WAAW,IAAI;AACxC;;AAGA,SAAgB,yBAAyB,OAAuB;CAC9D,IAAI,CAAC,qBAAqB,OAAO,MAAM,MAAM,CAAC,GAAG,OAAO;CAExD,IAAI,MAAM,QAAQ,OAAO;CACzB,IAAI,MAAM,WAAW,MAAM,OAAO;CAElC,OAAO,EAAE,MAAM,cAAc,CAAC,EAAC,CAAE,KAAK,qBAAqB;AAC7D;;AAGA,MAAM,2BAAW,IAAI,IAAY;AAEjC,SAAS,SAAS,OAAsB;CACtC,OAAO,GAAG,OAAO,MAAM,MAAM,CAAC,CAAC,YAAY,EAAE,GAAG,MAAM;AACxD;;;;;AAMA,SAAgB,8BACd,QACA,SAAmC,KAC1B;CACT,MAAM,QAAQ,OAAO,QAClB,UAAU,yBAAyB,KAAK,KAAK,CAAC,SAAS,IAAI,SAAS,KAAK,CAAC,CAC7E;CAEA,IAAI,MAAM,WAAW,GAAG,OAAO;CAE/B,KAAK,MAAM,SAAS,OAAO,SAAS,IAAI,SAAS,KAAK,CAAC;CAEvD,MAAM,WACJ,MAAM,WAAW,IACb,sEACA,GAAG,MAAM,OAAO;CAEtB,OAAO,KAAK;EACV,QAAQ;EACR,QAAQ;EACR,SACE,GAAG,SAAS,6KAGZ,MACG,KAAK,UAAU,OAAO,SAAS,KAAK,IAAI,MAAM,aAAa,KAAK,MAAM,WAAW,KAAK,IAAI,CAAC,CAC3F,KAAK,IAAI;EACd,SAAS,EACP,QAAQ,MAAM,KAAK,WAAW;GAC5B,QAAQ,MAAM;GACd,MAAM,MAAM;GACZ,MAAM,MAAM;GACZ,YAAY,MAAM;EACpB,EAAE,EACJ;CACF,CAAC;CAED,OAAO;AACT;;AAGA,SAAgB,6BAAmC;CACjD,SAAS,MAAM;AACjB"}

package/esm/socket/index.d.mts

@@ -1,2 +1,3 @@
 import { SocketAdapterFactory, SocketOptions } from "./types.mjs";
-import { getSocketServer } from "./utils.mjs";
+import { getSocketServer } from "./utils.mjs";
+export { SocketAdapterFactory, SocketOptions, getSocketServer };

package/esm/socket/index.mjs

@@ -1,3 +1,3 @@
 import { getSocketServer } from "./utils.mjs";
 
-export {  };
+export { getSocketServer };

package/esm/socket/types.d.mts

@@ -1,15 +1,14 @@
 import { Server } from "socket.io";
-
 //#region ../../packages/core/src/socket/types.d.ts
 /**
  * Factory that returns a Socket.IO adapter (constructor or instance), exactly
  * what `io.adapter()` accepts. Receives the freshly created server.
  */
-type SocketAdapterFactory = (io: Server) => unknown | Promise<unknown>;
+export type SocketAdapterFactory = (io: Server) => unknown | Promise<unknown>;
 /**
  * Socket options
  */
-type SocketOptions = {
+export type SocketOptions = {
   /**
    * Http Port, use it if the http is not enabled in the project
    */
@@ -37,5 +36,4 @@ type SocketOptions = {
   silenceSingleServerWarning?: boolean;
 };
 //#endregion
-export { SocketAdapterFactory, SocketOptions };
 //# sourceMappingURL=types.d.mts.map

package/esm/socket/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/socket/types.ts"],"mappings":";;;;;AAMA;;KAAY,oBAAA,IAAwB,EAAA,EAAI,MAAA,eAAqB,OAAO;;;;KAKxD,aAAA;EALwD;AAAA;AAKpE;EAIE,IAAA;;;;EAIA,OAAA,GAAU,OAAA,qBAA4B,aAAA;EAU5B;;;;EALV,GAAA;IAAQ,GAAA,WAAc,MAAA;IAAQ,IAAA,WAAe,MAAA;EAAA;EAArC;;;;EAKR,OAAA,GAAU,oBAAA;EAAA;;;EAIV,0BAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/socket/types.ts"],"mappings":";;;;;;YAMY,wBAAwB,IAAI,qBAAqB;;;;YAKjD;;;;EAIV;;;;EAIA,UAAU,4BAA4B;;;;;EAKtC;IAAQ,cAAc;IAAQ,eAAe;;;;;;EAK7C,UAAU;;;;EAIV"}

package/esm/socket/utils.d.mts

@@ -1,10 +1,8 @@
 import { Server } from "socket.io";
-
 //#region ../../packages/core/src/socket/utils.d.ts
 /**
  * Get socket server instance
  */
-declare function getSocketServer(): Server | null;
+export declare function getSocketServer(): Server | null;
 //#endregion
-export { getSocketServer };
 //# sourceMappingURL=utils.d.mts.map

package/esm/socket/utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/socket/utils.ts"],"mappings":";;;;;AAMA;iBAAgB,eAAA,IAAmB,MAAM"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/socket/utils.ts"],"mappings":";;;;;wBAMgB,mBAAmB"}

package/esm/storage/config.d.mts

@@ -1,19 +1,17 @@
 import { CloudStorageDriverOptions, LocalStorageDriverOptions, R2StorageDriverOptions, StorageConfigurations, StorageDriverConfig } from "./types.mjs";
 import { S3ClientConfig } from "@aws-sdk/client-s3";
-
 //#region ../../packages/core/src/storage/config.d.ts
 /**
  * Get storage configuration
  */
-declare function storageConfig(): StorageConfigurations;
-declare function storageConfig<T = any>(key: string): T;
-declare function storageConfig<T = any>(key: string, defaultValue: T): T;
-declare const storageConfigurations: {
+export declare function storageConfig(): StorageConfigurations;
+export declare function storageConfig<T = any>(key: string): T;
+export declare function storageConfig<T = any>(key: string, defaultValue: T): T;
+export declare const storageConfigurations: {
   local: (options: LocalStorageDriverOptions) => StorageDriverConfig;
   aws: (options: CloudStorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
   r2: (options: R2StorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
   spaces: (options: CloudStorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
 };
 //#endregion
-export { storageConfig, storageConfigurations };
 //# sourceMappingURL=config.d.mts.map

package/esm/storage/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/storage/config.ts"],"mappings":";;;;;;AAaA;iBAAgB,aAAA,IAAiB,qBAAqB;AAAA,iBACtC,aAAA,UAAuB,GAAA,WAAc,CAAC;AAAA,iBACtC,aAAA,UAAuB,GAAA,UAAa,YAAA,EAAc,CAAA,GAAI,CAAC;AAAA,cAS1D,qBAAA;mBACM,yBAAA,KAA4B,mBAAA;iBAM9B,yBAAA,GAA4B,cAAA,KAAiB,mBAAA;gBAM9C,sBAAA,GAAyB,cAAA,KAAiB,mBAAA;oBAMtC,yBAAA,GAA4B,cAAA,KAAiB,mBAAA;AAAA"}
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/storage/config.ts"],"mappings":";;;;;;wBAagB,iBAAiB;wBACjB,cAAc,SAAS,cAAc;wBACrC,cAAc,SAAS,aAAa,cAAc,IAAI;qBASzD;EACX,QAAK,SAAY,8BAA4B;EAM7C,MAAG,SAAY,4BAA4B,mBAAiB;EAM5D,KAAE,SAAY,yBAAyB,mBAAiB;EAMxD,SAAM,SAAY,4BAA4B,mBAAiB"}

package/esm/storage/context/storage-driver-context.d.mts

@@ -1,8 +1,7 @@
 import { StorageDriverContract } from "../types.mjs";
 import { Context } from "@warlock.js/context";
-
 //#region ../../packages/core/src/storage/context/storage-driver-context.d.ts
-type StorageDriverContextStore = {
+export type StorageDriverContextStore = {
   driver?: StorageDriverContract;
   prefix?: string;
   metadata?: Record<string, any>;
@@ -66,7 +65,7 @@ declare class StorageDriverContext extends Context<StorageDriverContextStore> {
    */
   buildStore(): StorageDriverContextStore;
 }
-declare const storageDriverContext: StorageDriverContext;
+export declare const storageDriverContext: StorageDriverContext;
 //#endregion
-export { StorageDriverContextStore, storageDriverContext };
+export {};
 //# sourceMappingURL=storage-driver-context.d.mts.map

package/esm/storage/context/storage-driver-context.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-driver-context.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/context/storage-driver-context.ts"],"mappings":";;;;KAGY,yBAAA;EACV,MAAA,GAAS,qBAAA;EACT,MAAA;EACA,QAAA,GAAW,MAAM;AAAA;;;;;;;;AAAA;AACjB;;;;;;;;;;cAoBI,oBAAA,SAA6B,OAAA,CAAQ,yBAAA;EAAD;;;EAIjC,SAAA,IAAa,qBAAA;EAAA;;;EAOb,SAAA;EAiBA;;;EAVA,WAAA,IAAe,MAAA;EAYS;;;;;;EAFxB,SAAA,CACL,MAAA,EAAQ,qBAAA,EACR,OAAA;IAAY,MAAA;IAAiB,QAAA,GAAW,MAAA;EAAA;EAwC/B;;;;AAAiD;;;;EAvBrD,SAAA,CAAU,MAAA;;;;EAOV,WAAA;;;;EAOA,UAAA,IAAc,yBAAA;AAAA;AAAA,cASV,oBAAA,EAAoB,oBAA6B"}
+{"version":3,"file":"storage-driver-context.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/context/storage-driver-context.ts"],"mappings":";;;YAGY;EACV,SAAS;EACT;EACA,WAAW;;;;;;;;;;;;;;;;;;;;cAqBP,6BAA6B,QAAQ;;;;EAIlC,aAAa;;;;EAOb;;;;EAOA,eAAe;;;;;;;EAUf,UACL,QAAQ,uBACR;IAAY;IAAiB,WAAW;;;;;;;;;;EAiBnC,UAAU;;;;EAOV;;;;EAOA,cAAc;;qBASV,sBAAoB"}

package/esm/storage/drivers/cloud-driver.d.mts

@@ -1,6 +1,5 @@
 import { CloudStorageDriverContract, CloudStorageDriverOptions, CloudStorageFileData, DeleteManyResult, FileVisibility, ListOptions, PresignedOptions, PresignedUploadOptions, PutOptions, StorageDriverType, StorageFileInfo } from "../types.mjs";
 import { Readable } from "stream";
-
 //#region ../../packages/core/src/storage/drivers/cloud-driver.d.ts
 /**
  * Load S3 modules lazily
@@ -11,7 +10,7 @@ import { Readable } from "stream";
  *   // Safe to use S3Client, S3Storage, S3Presigner
  * }
  */
-declare function loadS3(): Promise<void>;
+export declare function loadS3(): Promise<void>;
 /**
  * Base abstract class for all S3-compatible cloud storage drivers
  *
@@ -28,7 +27,7 @@ declare function loadS3(): Promise<void>;
  * - `name`: Driver identifier (e.g., "s3", "r2", "spaces")
  * - `url()`: Returns the public URL for a file (provider-specific format)
  */
-declare abstract class CloudDriver<TOptions extends Partial<CloudStorageDriverOptions> = CloudStorageDriverOptions> implements CloudStorageDriverContract {
+export declare abstract class CloudDriver<TOptions extends Partial<CloudStorageDriverOptions> = CloudStorageDriverOptions> implements CloudStorageDriverContract {
   options: TOptions;
   /**
    * S3-compatible client (lazy-loaded)
@@ -230,5 +229,4 @@ declare abstract class CloudDriver<TOptions extends Partial<CloudStorageDriverOp
   protected guessMimeType(location: string): string;
 }
 //#endregion
-export { CloudDriver, loadS3 };
 //# sourceMappingURL=cloud-driver.d.mts.map

package/esm/storage/drivers/cloud-driver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cloud-driver.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/drivers/cloud-driver.ts"],"mappings":"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"}
+{"version":3,"file":"cloud-driver.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/drivers/cloud-driver.ts"],"mappings":";;;;;;;;;;;;wBA2DsB,UAAU;;;;;;;;;;;;;;;;;8BAuFV,YACpB,iBAAiB,QAAQ,6BAA6B,sCAC3C;EAyCe,SAAS;;;;YArCzB,QAAS,iDAAiD;;;;YAK1D;IACR;IACA;IACA;IACA;;;;;;;;gBASY;;;;;;YASJ,WAAW,aAAa;EAUlC,YAA0B,SAAS;;;;oBAkDV,MAAM;;;;;WAMf,IAAI;;;;;YAMV;;;;;;;;;;EAiBH,YAAY;;;;;YAwBT,cAAc;;;;;;;;;;;YAiBR,UAAU,GACxB,iBAAiB,QAAQ,IACzB,yBACC,QAAQ;;;;;;;;;;;;;;;;;;;YAsDD,iBAAiB;;;;EAmCd,IACX,MAAM,QACN,kBACA,UAAU,aACT,QAAQ;;;;;;;;;EA8CE,YACX,MAAM,iBACN,kBACA,UAAU,aACT,QAAQ;;;;;EA6DE,UACX,QAAQ,UACR,kBACA,UAAU,aACT,QAAQ;;;;EAgDE,IAAI,mBAAmB,QAAQ;;;;EAyB/B,UAAU,mBAAmB,QAAQ;;;;EAyBrC,OAAO,mBAAmB;;;;EAqB1B,WAAW,sBAAsB,QAAQ;;;;;;;;;;EAqDzC,gBAAgB,wBAAwB;;;;EA0DxC,OAAO,mBAAmB;;;;EAsC1B,aAAa,kBAAkB,qBAAmB;;;;EAOlD,gBAAgB,kBAAkB,UAAU,mBAAmB;;;;EAsB/D,sBACX,kBACA,UAAU,yBACT;;;;EA4BU,SAAS,mBAAmB,QAAQ;;;;EA+BpC,KAAK,mBAAmB;;;;YAY3B,WAAW;;;;EASR,KAAK,cAAc,aAAa,QAAQ;;;;EA8CxC,KAAK,cAAc,aAAa,QAAQ;;;;EASxC,KAAK,mBAAmB,UAAU,cAAc,QAAQ;;;;EA6D9D;;;;EAOA;;;;EAOM,gBAAgB,kBAAkB,uBAAuB;;;;EAsBzD,cAAc,kBAAkB,YAAY,iBAAiB;;;;EAwB7D,cAAc,mBAAmB,QAAQ;;;;YAgC5C,cAAc,QAAQ;;;;YAOtB,cAAc"}