alepha 0.7.7 → 0.8.0

package/retry.d.ts

@@ -1,71 +1,91 @@
-import { MaybePromise } from "@alepha/core";
+import { AlephaError, MaybePromise } from "alepha";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$retry.d.ts
 
+// TODO: move to RetryProvider
 /**
- * `$retry` creates a retry descriptor.
- *
- * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
- *
- * @example
- * ```ts
- * import { $retry } from "@alepha/core";
- *
- * class MyService {
- * 	fetchData = $retry({
- * 		max: 5, // maximum number of attempts
- * 		delay: 1000, // ms
- * 		when: (error) => error.message.includes("Network Error"),
- * 		handler: async (url: string) => {
- * 			const response = await fetch(url);
- * 			if (!response.ok) {
- * 				throw new Error(`Failed to fetch: ${response.statusText}`);
- * 			}
- * 			return response.json();
- * 		},
- * 		onError: (error, attempt, url) => {
- * 	    // error happened, log it or handle it
- * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
- * 		},
- * 	});
- * }
- * ```
- */
+* Creates a function that automatically retries a handler upon failure,
+* with support for exponential backoff, max duration, and cancellation.
+*/
 declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
-/**
- * Retry Descriptor options.
- */
+declare const createRetryHandler: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>, dateTimeProvider: DateTimeProvider, appAbortController?: AbortController) => RetryDescriptor<T>;
+// ---------------------------------------------------------------------------------------------------------------------
+interface RetryBackoffOptions {
+  /**
+  * Initial delay in milliseconds.
+  *
+  * @default 200
+  */
+  initial?: number;
+  /**
+  * Multiplier for each subsequent delay.
+  *
+  * @default 2
+  */
+  factor?: number;
+  /**
+  * Maximum delay in milliseconds.
+  */
+  max?: number;
+  /**
+  * If true, adds a random jitter to the delay to prevent thundering herd.
+  *
+  * @default true
+  */
+  jitter?: boolean;
+}
 interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
   /**
-   * Maximum number of attempts.
-   *
-   * @default 3
-   */
+  * The function to retry.
+  */
+  handler: T;
+  /**
+  * The maximum number of attempts.
+  *
+  * @default 3
+  */
   max?: number;
   /**
-   * Delay in milliseconds.
-   *
-   * @default 0
-   */
-  delay?: number;
+  * The backoff strategy for delays between retries.
+  * Can be a fixed number (in ms) or a configuration object for exponential backoff.
+  *
+  * @default { initial: 200, factor: 2, jitter: true }
+  */
+  backoff?: number | RetryBackoffOptions;
+  /**
+  * An overall time limit for all retry attempts combined.
+  *
+  * e.g., `[5, 'seconds']`
+  */
+  maxDuration?: DurationLike;
   /**
-   * Optional condition to determine when to retry.
-   */
+  * A function that determines if a retry should be attempted based on the error.
+  *
+  * @default (error) => true (retries on any error)
+  */
   when?: (error: Error) => boolean;
   /**
-   * The function to retry.
-   */
-  handler: T;
+  * A custom callback for when a retry attempt fails.
+  * This is called before the delay.
+  */
+  onError?: (error: Error, attempt: number, ...args: Parameters<T>) => void;
   /**
-   * Optional error handler.
-   *
-   * This will be called when an error occurs.
-   *
-   * @default undefined
-   */
-  onError?: (error: Error, attempt: number, ...parameters: Parameters<T>) => void;
+  * An AbortSignal to allow for external cancellation of the retry loop.
+  */
+  signal?: AbortSignal;
 }
 type RetryDescriptor<T extends (...args: any[]) => any> = (...parameters: Parameters<T>) => MaybePromise<ReturnType<T>>;
 //#endregion
-export { $retry, RetryDescriptor, RetryDescriptorOptions };
+//#region src/errors/RetryCancelError.d.ts
+declare class RetryCancelError extends AlephaError {
+  constructor();
+}
+//#endregion
+//#region src/errors/RetryTimeoutError.d.ts
+declare class RetryTimeoutError extends AlephaError {
+  constructor(duration: number);
+}
+//#endregion
+export { $retry, RetryBackoffOptions, RetryCancelError, RetryDescriptor, RetryDescriptorOptions, RetryTimeoutError, createRetryHandler };
 //# sourceMappingURL=index.d.ts.map

package/scheduler.d.ts

@@ -1,10 +1,9 @@
-import * as _alepha_core9 from "@alepha/core";
-import * as _alepha_core2 from "@alepha/core";
-import { Alepha, Async, KIND, OPTIONS, Static } from "@alepha/core";
-import * as _alepha_lock8 from "@alepha/lock";
-import { DateTime, DateTimeProvider, DurationLike, Interval } from "@alepha/datetime";
+import * as _alepha_core9 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Async, KIND, OPTIONS, Static } from "alepha";
+import * as _alepha_lock8 from "alepha/lock";
+import { DateTime, DateTimeProvider, DurationLike, Interval } from "alepha/datetime";
 import { Cron } from "cron-schedule";
-import * as _sinclair_typebox0 from "@sinclair/typebox";
 import * as dayjs10 from "dayjs";
 
 //#region src/descriptors/$scheduler.d.ts
@@ -77,16 +76,17 @@ declare class CronProvider {
   }) => Promise<void>): CronJob;
   run(task: CronJob, now?: dayjs10.Dayjs): void;
 }
+//# sourceMappingURL=CronScheduler.d.ts.map
 //#endregion
 //#region src/providers/SchedulerDescriptorProvider.d.ts
-declare const envSchema: _alepha_core2.TObject<{
-  SCHEDULER_PREFIX: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+declare const envSchema: _alepha_core0.TObject<{
+  SCHEDULER_PREFIX: _alepha_core0.TOptional<_alepha_core0.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 declare class SchedulerDescriptorProvider {
-  protected readonly log: _alepha_core2.Logger;
+  protected readonly log: _alepha_core0.Logger;
   protected readonly env: {
     SCHEDULER_PREFIX?: string | undefined;
   };
@@ -94,9 +94,9 @@ declare class SchedulerDescriptorProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly cronProvider: CronProvider;
   protected readonly schedulers: Scheduler[];
-  protected readonly configure: _alepha_core2.HookDescriptor<"configure">;
-  protected readonly start: _alepha_core2.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core2.HookDescriptor<"stop">;
+  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  protected readonly start: _alepha_core0.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core0.HookDescriptor<"stop">;
   /**
    * Get the schedulers.
    */
@@ -154,6 +154,8 @@ declare class AlephaScheduler {
   readonly name = "alepha.scheduler";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $scheduler, AlephaScheduler, Scheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerHandlerArguments, isScheduler };
 //# sourceMappingURL=index.d.ts.map

package/security.d.ts

@@ -1,10 +1,9 @@
-import * as _alepha_core7 from "@alepha/core";
-import * as _alepha_core2 from "@alepha/core";
-import { Alepha, KIND, OPTIONS, Static } from "@alepha/core";
-import { DateTimeProvider } from "@alepha/datetime";
+import * as _alepha_core15 from "alepha";
+import * as _alepha_core16 from "alepha";
+import { Alepha, KIND, OPTIONS, Static } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
 import { CryptoKey, FlattenedJWSInput, JSONWebKeySet, JWSHeaderParameters, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject } from "jose";
-import * as _sinclair_typebox8 from "@sinclair/typebox";
-import * as _sinclair_typebox18 from "@sinclair/typebox";
+import * as _sinclair_typebox22 from "@sinclair/typebox";
 import * as _sinclair_typebox1 from "@sinclair/typebox";
 
 //#region src/interfaces/UserAccountInfo.d.ts
@@ -37,16 +36,18 @@ interface UserAccountInfo {
    */
   organization?: string;
 }
+//# sourceMappingURL=UserAccountInfo.d.ts.map
 //#endregion
 //#region src/schemas/permissionSchema.d.ts
-declare const permissionSchema: _sinclair_typebox8.TObject<{
-  name: _sinclair_typebox8.TString;
-  group: _sinclair_typebox8.TOptional<_sinclair_typebox8.TString>;
-  description: _sinclair_typebox8.TOptional<_sinclair_typebox8.TString>;
-  method: _sinclair_typebox8.TOptional<_sinclair_typebox8.TString>;
-  path: _sinclair_typebox8.TOptional<_sinclair_typebox8.TString>;
+declare const permissionSchema: _sinclair_typebox22.TObject<{
+  name: _sinclair_typebox22.TString;
+  group: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
+  description: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
+  method: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
+  path: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
 }>;
 type Permission = Static<typeof permissionSchema>;
+//# sourceMappingURL=permissionSchema.d.ts.map
 //#endregion
 //#region src/descriptors/$permission.d.ts
 declare const KEY$2 = "PERMISSION";
@@ -102,26 +103,28 @@ interface UserAccountToken extends UserAccountInfo {
    */
   ownership?: string | boolean;
 }
+//# sourceMappingURL=UserAccountToken.d.ts.map
 //#endregion
 //#region src/schemas/roleSchema.d.ts
-declare const roleSchema: _sinclair_typebox18.TObject<{
-  name: _sinclair_typebox18.TString;
-  description: _sinclair_typebox18.TOptional<_sinclair_typebox18.TString>;
-  default: _sinclair_typebox18.TOptional<_sinclair_typebox18.TBoolean>;
-  permissions: _sinclair_typebox18.TArray<_sinclair_typebox18.TObject<{
-    name: _sinclair_typebox18.TString;
-    ownership: _sinclair_typebox18.TOptional<_sinclair_typebox18.TBoolean>;
-    exclude: _sinclair_typebox18.TOptional<_sinclair_typebox18.TArray<_sinclair_typebox18.TString>>;
+declare const roleSchema: _sinclair_typebox1.TObject<{
+  name: _sinclair_typebox1.TString;
+  description: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+  default: _sinclair_typebox1.TOptional<_sinclair_typebox1.TBoolean>;
+  permissions: _sinclair_typebox1.TArray<_sinclair_typebox1.TObject<{
+    name: _sinclair_typebox1.TString;
+    ownership: _sinclair_typebox1.TOptional<_sinclair_typebox1.TBoolean>;
+    exclude: _sinclair_typebox1.TOptional<_sinclair_typebox1.TArray<_sinclair_typebox1.TString>>;
   }>>;
 }>;
 type Role = Static<typeof roleSchema>;
+//# sourceMappingURL=roleSchema.d.ts.map
 //#endregion
 //#region src/providers/JwtProvider.d.ts
 /**
  * Provides utilities for working with JSON Web Tokens (JWT).
  */
 declare class JwtProvider {
-  protected readonly log: _alepha_core7.Logger;
+  protected readonly log: _alepha_core15.Logger;
   protected readonly keystore: KeyLoaderHolder[];
   protected readonly dateTimeProvider: DateTimeProvider;
   /**
@@ -202,10 +205,11 @@ interface JwtParseResult {
   keyName: string;
   result: JWTVerifyResult<ExtendedJWTPayload>;
 }
+//# sourceMappingURL=JwtProvider.d.ts.map
 //#endregion
 //#region src/providers/SecurityProvider.d.ts
-declare const envSchema: _alepha_core2.TObject<{
-  SECURITY_SECRET_KEY: _sinclair_typebox1.TString;
+declare const envSchema: _alepha_core16.TObject<{
+  SECURITY_SECRET_KEY: _alepha_core16.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -214,7 +218,7 @@ declare class SecurityProvider {
   protected readonly UNKNOWN_USER_NAME = "Unknown User";
   protected readonly PERMISSION_REGEXP: RegExp;
   protected readonly PERMISSION_REGEXP_WILDCARD: RegExp;
-  protected readonly log: _alepha_core2.Logger;
+  protected readonly log: _alepha_core16.Logger;
   protected readonly jwt: JwtProvider;
   protected readonly env: {
     SECURITY_SECRET_KEY: string;
@@ -232,7 +236,7 @@ declare class SecurityProvider {
    * Create realms.
    */
   protected createRealms(): Realm[];
-  protected configure: _alepha_core2.HookDescriptor<"configure">;
+  protected configure: _alepha_core16.HookDescriptor<"configure">;
   /**
    * Processes all $permission descriptors.
    */
@@ -245,7 +249,7 @@ declare class SecurityProvider {
    * Processes all $role descriptors.
    */
   protected processRoleDescriptors(): void;
-  protected ready: _alepha_core2.HookDescriptor<"ready">;
+  protected ready: _alepha_core16.HookDescriptor<"ready">;
   /**
    * Updates the roles for a realm then synchronizes the user account provider if available.
    *
@@ -482,7 +486,7 @@ declare const $role: {
  *
  * @example
  * ```ts
- * import { $serviceAccount } from "@alepha/security";
+ * import { $serviceAccount } from "alepha/security";
  *
  * class MyService {
  *   serviceAccount = $serviceAccount({
@@ -539,20 +543,24 @@ interface AccessTokenResponse {
 interface ServiceAccountStore {
   response?: AccessTokenResponse;
 }
+//# sourceMappingURL=$serviceAccount.d.ts.map
 //#endregion
 //#region src/errors/InvalidPermissionError.d.ts
 declare class InvalidPermissionError extends Error {
   constructor(name: string);
 }
+//# sourceMappingURL=InvalidPermissionError.d.ts.map
 //#endregion
 //#region src/errors/SecurityError.d.ts
 declare class SecurityError extends Error {
   readonly status = 403;
   readonly code = "ERR_SECURITY";
 }
+//# sourceMappingURL=SecurityError.d.ts.map
+
 //#endregion
 //#region src/index.d.ts
-declare module "alepha/core" {
+declare module "alepha" {
   interface Hooks {
     "security:user:created": {
       realm: string;
@@ -564,6 +572,8 @@ declare class AlephaSecurity {
   readonly name = "alepha.security";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $permission, $realm, $role, $serviceAccount, AccessTokenResponse, AlephaSecurity, ExtendedJWTPayload, InvalidPermissionError, JwtParseResult, JwtProvider, JwtServiceAccountDescriptorOptions, JwtSignOptions, KeyLoader, KeyLoaderHolder, Oauth2ServiceAccountDescriptorOptions, Permission, PermissionDescriptor, PermissionDescriptorOptions, Realm, RealmConfig, RealmDescriptor, RealmDescriptorOptions, Role, RoleDescriptor, RoleDescriptorOptions, SecurityCheckResult, SecurityError, SecurityProvider, SecurityUserAccountProvider, ServiceAccountDescriptor, ServiceAccountDescriptorOptions, ServiceAccountStore, UserAccountInfo, UserAccountToken, permissionSchema, roleSchema };
 //# sourceMappingURL=index.d.ts.map

package/server/cache.d.ts

@@ -1,8 +1,8 @@
-import { Cache, CacheDescriptorOptions, CacheDescriptorProvider } from "@alepha/cache";
-import { ServerHandler, ServerRequestConfig } from "@alepha/server";
-import * as _alepha_core1 from "@alepha/core";
-import { Alepha, Module, OPTIONS } from "@alepha/core";
-import { DateTimeProvider, DurationLike } from "@alepha/datetime";
+import { Cache, CacheDescriptorOptions, CacheDescriptorProvider } from "alepha/cache";
+import { ServerHandler, ServerRequestConfig } from "alepha/server";
+import * as _alepha_core1 from "alepha";
+import { Alepha, Module, OPTIONS } from "alepha";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/providers/ServerCacheProvider.d.ts
 declare module "alepha/server" {
@@ -80,6 +80,8 @@ declare class AlephaServerCache implements Module {
   readonly name = "alepha.server.cache";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
 //# sourceMappingURL=index.d.ts.map

package/server/compress.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-compress');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/compress.d.ts

@@ -0,0 +1,26 @@
+import { ServerResponse } from "alepha/server";
+import { Transform } from "node:stream";
+import { Alepha, HookDescriptor, Module } from "alepha";
+
+//#region src/providers/ServerCompressProvider.d.ts
+declare class ServerCompressProvider {
+  compressors: Record<string, {
+    compress: (...args: any[]) => Promise<Buffer>;
+    stream: (options?: any) => Transform;
+  } | undefined>;
+  readonly onResponse: HookDescriptor<"server:onResponse">;
+  protected isAllowedContentType(contentType: string | undefined): boolean;
+  protected compress(encoding: keyof typeof (void 0).compressors, response: ServerResponse): Promise<void>;
+  protected getParams(encoding: keyof typeof (void 0).compressors): Record<number, any>;
+  protected setHeaders(response: ServerResponse, encoding: keyof typeof (void 0).compressors): void;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+declare class AlephaServerCompress implements Module {
+  readonly name = "alepha.server.compress";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerCompress, ServerCompressProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/compress.js

@@ -0,0 +1 @@
+export * from '@alepha/server-compress'

package/server/cookies.d.ts

@@ -1,32 +1,59 @@
-import * as _alepha_core1 from "@alepha/core";
-import { KIND, OPTIONS, Static, TSchema } from "@alepha/core";
-import { DurationLike } from "@alepha/datetime";
+import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TObject, TOptional, TSchema, TString } from "alepha";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$cookie.d.ts
+declare const KEY = "COOKIE";
 interface CookieDescriptorOptions<T extends TSchema> {
+  /** The schema for the cookie's value, used for validation and type safety. */
   schema: T;
-  name: string;
+  /** The name of the cookie. */
+  name?: string;
+  /** The cookie's path. Defaults to "/". */
   path?: string;
+  /** Time-to-live for the cookie. Maps to `Max-Age`. */
   ttl?: DurationLike;
+  /** If true, the cookie is only sent over HTTPS. Defaults to true in production. */
   secure?: boolean;
+  /** If true, the cookie cannot be accessed by client-side scripts. */
   httpOnly?: boolean;
+  /** SameSite policy for the cookie. Defaults to "lax". */
   sameSite?: "strict" | "lax" | "none";
+  /** The domain for the cookie. */
   domain?: string;
+  /** If true, the cookie value will be compressed using zlib. */
   compress?: boolean;
+  /** If true, the cookie value will be encrypted. Requires `COOKIE_SECRET` env var. */
   encrypt?: boolean;
+  /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
 interface CookieDescriptor<T extends TSchema> {
-  [KIND]: "COOKIE";
+  [KIND]: typeof KEY;
   [OPTIONS]: CookieDescriptorOptions<T>;
-  set: (cookies: Cookies, value: Static<T>) => void;
-  get: (cookies: Cookies) => Static<T> | undefined;
-  del: (cookies: Cookies) => void;
+  schema: T;
+  /** Sets the cookie with the given value in the current request's response. */
+  set: (value: Static<T>, options?: {
+    cookies?: Cookies;
+  }) => void;
+  /** Gets the cookie value from the current request. Returns undefined if not found or invalid. */
+  get: (options?: {
+    cookies?: Cookies;
+  }) => Static<T> | undefined;
+  /** Deletes the cookie in the current request's response. */
+  del: (options?: {
+    cookies?: Cookies;
+  }) => void;
 }
+/**
+* Declares a type-safe, configurable HTTP cookie.
+* This descriptor provides methods to get, set, and delete the cookie
+* within the server request/response cycle.
+*/
 declare const $cookie: {
   <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
   [KIND]: string;
 };
+// ---------------------------------------------------------------------------------------------------------------------
 interface Cookies {
   req: Record<string, string>;
   res: Record<string, Cookie | null>;
@@ -42,22 +69,49 @@ interface Cookie {
 }
 //#endregion
 //#region src/providers/ServerCookiesProvider.d.ts
+declare const envSchema: TObject<{
+  COOKIE_SECRET: TOptional<TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
 declare class ServerCookiesProvider {
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
-  fromHeader(header: string): Record<string, string>;
-  toHeader(cookies: Record<string, Cookie | null>, isHttps?: boolean): string[];
+  protected readonly alepha: Alepha;
+  protected readonly log: Logger;
+  protected readonly env: Static<typeof envSchema>;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  // Crypto constants
+  protected readonly ALGORITHM = "aes-256-gcm";
+  protected readonly IV_LENGTH = 16;
+  protected readonly AUTH_TAG_LENGTH = 16;
+  protected readonly SIGNATURE_LENGTH = 32;
+  protected readonly configure: HookDescriptor<"configure">;
+  protected createApi<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
+  readonly onRequest: HookDescriptor<"server:onRequest">;
+  readonly onSend: HookDescriptor<"server:onSend">;
+  protected getCookiesFromContext(cookies?: Cookies): Cookies;
+  protected getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
+  protected setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
+  protected deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
+  // --- Crypto & Parsing ---
+  protected encrypt(text: string): string;
+  protected decrypt(encryptedText: string): string;
+  secretKey(): string;
+  protected sign(data: string): string;
+  protected parseRequestCookies(header: string): Record<string, string>;
+  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 declare module "alepha/server" {
   interface ServerRequest {
     cookies: Cookies;
   }
 }
-declare class AlephaServerCookies {
+declare class AlephaServerCookies implements Module {
   readonly name = "alepha.server.cookies";
-  readonly $services: (alepha: any) => void;
+  readonly $services: (alepha: Alepha) => void;
 }
 //#endregion
 export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };

package/server/cors.d.ts

@@ -1,12 +1,15 @@
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, Module } from "@alepha/core";
+import { ServerRouterProvider } from "alepha/server";
+import { Alepha, HookDescriptor, Module } from "alepha";
 
 //#region src/providers/ServerCorsProvider.d.ts
 declare class ServerCorsProvider {
+  protected readonly serverRouterProvider: ServerRouterProvider;
   options: CorsOptions;
-  protected readonly onRequest: _alepha_core0.HookDescriptor<"server:onRequest">;
+  protected readonly onRoute: HookDescriptor<"server:onRoute">;
+  protected readonly onRequest: HookDescriptor<"server:onRequest">;
   isOriginAllowed(origin: string | undefined, allowed: CorsOptions["origin"]): boolean;
 }
+// ---------------------------------------------------------------------------------------------------------------------
 interface CorsOptions {
   origin?: string | string[] | ((origin: string | undefined) => boolean);
   methods: string[];
@@ -16,6 +19,7 @@ interface CorsOptions {
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 declare class AlephaServerCors implements Module {
   readonly name = "alepha.server.cors";
   readonly $services: (alepha: Alepha) => void;

package/server/health.d.ts

@@ -1,41 +1,41 @@
-import * as _alepha_server5 from "@alepha/server";
-import { Alepha } from "@alepha/core";
-import { DateTimeProvider } from "@alepha/datetime";
-import * as _sinclair_typebox0 from "@sinclair/typebox";
+import { RouteDescriptor } from "alepha/server";
+import { Alepha, TBoolean, TNumber, TObject, TString } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
 
 //#region src/providers/ServerHealthProvider.d.ts
 
 /**
- * Register `/health` endpoint.
- *
- * - Provides basic health information about the server.
- */
+* Register `/health` endpoint.
+*
+* - Provides basic health information about the server.
+*/
 declare class ServerHealthProvider {
-  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly time: DateTimeProvider;
   protected readonly alepha: Alepha;
-  readonly health: _alepha_server5.RouteDescriptor<{
-    response: _sinclair_typebox0.TObject<{
-      message: _sinclair_typebox0.TString;
-      uptime: _sinclair_typebox0.TNumber;
-      date: _sinclair_typebox0.TString;
-      ready: _sinclair_typebox0.TBoolean;
+  readonly health: RouteDescriptor<{
+    response: TObject<{
+      message: TString;
+      uptime: TNumber;
+      date: TString;
+      ready: TBoolean;
     }>;
   }>;
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Server Health Module
- *
- * @description
- * Plugin for Alepha Server that provides health-check endpoints.
- *
- * @see {@link ServerHealthProvider}
- * @module alepha.server.health
- */
+* Alepha Server Health Module
+*
+* @description
+* Plugin for Alepha Server that provides health-check endpoints.
+*
+* @see {@link ServerHealthProvider}
+* @module alepha.server.health
+*/
 declare class AlephaServerHealth {
   readonly name = "alepha.server.health";
-  readonly $services: (alepha: any) => void;
+  readonly $services: (alepha: Alepha) => void;
 }
 //#endregion
 export { AlephaServerHealth, ServerHealthProvider };

package/server/helmet.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-helmet');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});