alepha 0.7.6 → 0.8.0

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,10 +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 createContextId(): string;
+  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  protected readonly start: _alepha_core0.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core0.HookDescriptor<"stop">;
   /**
    * Get the schedulers.
    */
@@ -155,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_typebox20 from "@sinclair/typebox";
+import * as _sinclair_typebox22 from "@sinclair/typebox";
 import * as _sinclair_typebox1 from "@sinclair/typebox";
 
 //#region src/interfaces/UserAccountInfo.d.ts
@@ -37,17 +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>;
-  contentType: _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";
@@ -96,9 +96,6 @@ interface UserAccountToken extends UserAccountInfo {
    * Access token for the user.
    */
   token?: string;
-  /**
-   *
-   */
   realm?: string;
   /**
    * Is user dedicated to his own resources for this scope ?
@@ -106,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_typebox20.TObject<{
-  name: _sinclair_typebox20.TString;
-  description: _sinclair_typebox20.TOptional<_sinclair_typebox20.TString>;
-  default: _sinclair_typebox20.TOptional<_sinclair_typebox20.TBoolean>;
-  permissions: _sinclair_typebox20.TArray<_sinclair_typebox20.TObject<{
-    name: _sinclair_typebox20.TString;
-    ownership: _sinclair_typebox20.TOptional<_sinclair_typebox20.TBoolean>;
-    exclude: _sinclair_typebox20.TOptional<_sinclair_typebox20.TArray<_sinclair_typebox20.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;
   /**
@@ -206,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>> {}
@@ -218,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;
@@ -236,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.
    */
@@ -249,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.
    *
@@ -361,13 +361,7 @@ declare class SecurityProvider {
  * A realm definition.
  */
 interface Realm {
-  /**
-   *
-   */
   name: string;
-  /**
-   *
-   */
   roles: Role[];
   /**
    * The secret key for the realm.
@@ -464,9 +458,6 @@ interface RoleDescriptorOptions {
    * Describe the role.
    */
   description?: string;
-  /**
-   *
-   */
   permissions?: Array<string | {
     name: string;
     ownership?: boolean;
@@ -495,7 +486,7 @@ declare const $role: {
  *
  * @example
  * ```ts
- * import { $serviceAccount } from "@alepha/security";
+ * import { $serviceAccount } from "alepha/security";
  *
  * class MyService {
  *   serviceAccount = $serviceAccount({
@@ -552,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;
@@ -577,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" {
@@ -55,8 +55,8 @@ type RouteLike = {
  *
  * @example
  * ```ts
- * import { Alepha } from "@alepha/core";
- * import { $action } from "@alepha/server";
+ * import { Alepha } from "alepha";
+ * import { $action } from "alepha/server";
  * import { AlephaServerCache } from "alepha/server/cache";
  *
  * class ApiServer {
@@ -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,33 +1,59 @@
-import * as _alepha_core1 from "@alepha/core";
-import { KIND, OPTIONS, Static, TSchema } from "@alepha/core";
-import { DurationLike } from "@alepha/datetime";
-import "@alepha/server";
+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>;
@@ -43,19 +69,50 @@ 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 implements Module {
+  readonly name = "alepha.server.cookies";
+  readonly $services: (alepha: Alepha) => void;
+}
 //#endregion
-export { $cookie, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
+export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/cors.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-cors');
+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/cors.d.ts

@@ -0,0 +1,29 @@
+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 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[];
+  headers: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+declare class AlephaServerCors implements Module {
+  readonly name = "alepha.server.cors";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerCors, CorsOptions, ServerCorsProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/cors.js

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

package/server/health.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-health');
+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/health.d.ts

@@ -0,0 +1,42 @@
+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.
+*/
+declare class ServerHealthProvider {
+  protected readonly time: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  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
+*/
+declare class AlephaServerHealth {
+  readonly name = "alepha.server.health";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerHealth, ServerHealthProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/health.js

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

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]; }
+	});
+});

package/server/helmet.d.ts

@@ -0,0 +1,72 @@
+import { Alepha, HookDescriptor, Module } from "alepha";
+
+//#region src/providers/ServerHelmetProvider.d.ts
+type CspDirective = string | string[];
+interface CspOptions {
+  directives: {
+    "default-src"?: CspDirective;
+    "script-src"?: CspDirective;
+    "style-src"?: CspDirective;
+    "img-src"?: CspDirective;
+    "connect-src"?: CspDirective;
+    "font-src"?: CspDirective;
+    "object-src"?: CspDirective;
+    "media-src"?: CspDirective;
+    "frame-src"?: CspDirective;
+    sandbox?: CspDirective | boolean;
+    "report-uri"?: string;
+    "child-src"?: CspDirective;
+    "form-action"?: CspDirective;
+    "frame-ancestors"?: CspDirective;
+    "plugin-types"?: CspDirective;
+    "base-uri"?: CspDirective;
+    [key: string]: CspDirective | undefined | boolean;
+  };
+}
+interface HstsOptions {
+  maxAge?: number;
+  includeSubDomains?: boolean;
+  preload?: boolean;
+}
+interface HelmetOptions {
+  isSecure?: boolean;
+  strictTransportSecurity?: HstsOptions | false;
+  xContentTypeOptions?: false;
+  xFrameOptions?: "DENY" | "SAMEORIGIN" | false;
+  xXssProtection?: false;
+  contentSecurityPolicy?: CspOptions | false;
+  referrerPolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | false;
+}
+/**
+* Provides a configurable way to apply essential HTTP security headers
+* to every server response, without external dependencies.
+*/
+declare class ServerHelmetProvider {
+  protected readonly alepha: Alepha;
+  /**
+  * The configuration options. These can be overridden during
+  * the application's configuration phase using `alepha.configure()`.
+  */
+  options: HelmetOptions;
+  private buildHeaders;
+  protected readonly onResponse: HookDescriptor<"server:onResponse">;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Helmet Module
+*
+* Automatically adds important HTTP security headers to every response
+* to help protect your application from common web vulnerabilities.
+*
+* @see {@link ServerHelmetProvider}
+* @module alepha.server.helmet
+*/
+declare class AlephaServerHelmet implements Module {
+  readonly name = "alepha.server.helmet";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerHelmet, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/helmet.js

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

package/server/links.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-links');
+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]; }
+	});
+});