@expressots/core 4.0.0-preview.1 → 4.0.0-preview.3

package/lib/esm/types/lazy-loading/lazy-module-helpers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Standalone (free-function) wrappers around `LazyModule` chain methods.
+ *
+ * The fluent API (`module.withPreloadHint(...).withLazyConfig(...)`) remains
+ * the recommended style. These helpers exist so users can compose lazy
+ * configurations with point-free style or apply the same hint to a list of
+ * modules:
+ *
+ * ```ts
+ * import { CreateLazyModule, withPreloadHint, withLazyConfig } from "@expressots/core";
+ *
+ * const Admin = withPreloadHint(
+ *   CreateLazyModule([AdminController]),
+ *   "low",
+ * );
+ *
+ * const Analytics = withLazyConfig(
+ *   CreateLazyModule([AnalyticsController]),
+ *   { preloadHint: "medium", prefetchAfterIdle: 5000 },
+ * );
+ * ```
+ *
+ * @public API
+ */
+import type { ILazyModule, LazyModuleConfig, PreloadHint } from "./lazy.interfaces.js";
+/**
+ * Set a preload hint on the supplied lazy module and return it.
+ *
+ * Equivalent to `module.withPreloadHint(hint)`. Returned reference is the same
+ * instance — no copy is made.
+ *
+ * @public API
+ */
+export declare function withPreloadHint(module: ILazyModule, hint: PreloadHint): ILazyModule;
+/**
+ * Merge the supplied partial config into the lazy module and return it.
+ *
+ * Equivalent to `module.withLazyConfig(config)`.
+ *
+ * @public API
+ */
+export declare function withLazyConfig(module: ILazyModule, config: Partial<LazyModuleConfig>): ILazyModule;

package/lib/esm/types/middleware/index.d.ts

@@ -2,7 +2,6 @@ export { Middleware, ExpressHandler, ExpressoMiddleware, MiddlewareOptions, Midd
 export { ErrorHandlerOptions, IMiddleware, HealthCheckOptions, } from "./middleware-interface.js";
 export { middlewareResolver, isMiddlewareAvailable, isPackageAvailable, resolvePackage, getAvailableMiddleware, getRegisteredMiddleware, clearMiddlewareCache, getPackageName, MIDDLEWARE_REGISTRY, RegisteredMiddlewareName, } from "./middleware-resolver.js";
 export { MiddlewareProfiler, MiddlewareMetrics, ProfilerStats, } from "./middleware-profiler.js";
-export { MiddlewarePresetName, MiddlewarePreset, PresetMiddlewareConfig, ApplyPresetOptions, MIDDLEWARE_PRESETS, getPreset, getPresetNames, getPresetsByTag, createPreset, mergePresets, } from "./middleware-presets.js";
 export type { OptionsJson } from "./interfaces/body-parser.interface.js";
 export type { CorsOptions } from "./interfaces/cors.interface.js";
 export type { CompressionOptions } from "./interfaces/compression.interface.js";
@@ -19,6 +18,7 @@ export type * as IMorgan from "./interfaces/morgan.interface.js";
 export { ContentNegotiationService, FormatterRegistry, AcceptHeaderParser, JsonFormatter, XmlFormatter, CsvFormatter, YamlFormatter, PlainTextFormatter, } from "./content-negotiation/index.js";
 export type { IContentFormatter, ContentNegotiationOptions, AcceptHeaderEntry, NegotiationResult, CsvFormatOptions, XmlFormatOptions, YamlFormatOptions, } from "./interfaces/content-negotiation.interface.js";
 export { use, compose, when, parallel, timeout } from "./middleware-utils.js";
+export { definePreset, applyPreset, getStandalonePresetNames, clearStandalonePresets, } from "./presets-standalone.js";
 export { MiddlewareRegistry, getMiddlewareRegistry, resetMiddlewareRegistry, } from "./middleware-registry.js";
 export type { MiddlewareEntry as RegistryMiddlewareEntry } from "./middleware-registry.js";
 export { setGlobalUploadConfig, getGlobalUploadConfig, hasGlobalUploadConfig, clearGlobalUploadConfig, mergeUploadConfigs, } from "./upload-registry.js";

package/lib/esm/types/middleware/middleware-service.d.ts

@@ -250,6 +250,7 @@ export declare class Middleware implements IMiddleware {
     private profiler;
     private profilingEnabled;
     private customPresets;
+    private _lastPreset;
     private registry;
     private startupLogs;
     private registeredMiddlewareNames;
@@ -699,8 +700,28 @@ export declare class Middleware implements IMiddleware {
      * Get all available presets.
      */
     getAllPresets(): Record<string, V4MiddlewareConfig>;
+    /**
+     * Returns info about the last applied preset (name, whether overrides
+     * were used, and the effective merged config). Used by the adapter to
+     * forward preset metadata to Studio.
+     */
+    getLastAppliedPreset(): {
+        name: string;
+        hasOverrides: boolean;
+        config: V4MiddlewareConfig;
+    } | null;
     /**
      * Get built-in presets.
+     *
+     * Each preset is tuned for a specific workload:
+     * - api: REST APIs (large payloads, rate-limited, strict CORS)
+     * - web: traditional server-rendered apps (cookies, sessions, relaxed CORS)
+     * - spa: single-page apps served with static fallback
+     * - microservice: internal service-to-service (minimal surface, no security)
+     * - graphql: single endpoint with large JSON payloads
+     * - minimal: parsing only, no security or compression
+     * - development: relaxed for local iteration, verbose logging
+     * - production: hardened defaults for shipped deployments
      */
     private getBuiltInPresets;
     /**

package/lib/esm/types/middleware/presets-standalone.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Standalone (free-function) wrappers around the v4 middleware preset system.
+ *
+ * These exist alongside the `Middleware.definePreset` / `Middleware.applyPreset`
+ * instance methods so user code that doesn't have DI access to the `Middleware`
+ * provider — for example, declarative config files outside of the request
+ * lifecycle — can still register and apply presets.
+ *
+ * Usage:
+ * ```ts
+ * import { definePreset, applyPreset } from "@expressots/core";
+ *
+ * definePreset("my-api", {
+ *   parse: { json: { limit: "1mb" } },
+ *   security: { cors: { origin: "https://app.example.com" } },
+ * });
+ *
+ * // ...later, inside configureServices(), with the Middleware DI provider:
+ * applyPreset(this.services.middleware, "my-api");
+ * ```
+ *
+ * @public API
+ */
+import type { Middleware } from "./middleware-service.js";
+import type { MiddlewareConfig } from "./middleware-config.js";
+/**
+ * Register a custom middleware preset under the given name.
+ *
+ * The preset is stored in a module-level registry so it can be referenced
+ * later by `applyPreset(middleware, name)`. Calling `definePreset` with an
+ * existing name overwrites the previous definition.
+ *
+ * @param name   unique identifier for the preset
+ * @param config v4 middleware config object describing the preset
+ *
+ * @public API
+ */
+export declare function definePreset(name: string, config: MiddlewareConfig): void;
+/**
+ * Apply a previously defined preset (built-in or registered via
+ * `definePreset`) to the supplied `Middleware` instance.
+ *
+ * Resolution order:
+ *  1. Built-in v4 presets (`api`, `web`, `spa`, `microservice`, `graphql`,
+ *     `minimal`, `development`, `production`) are matched by the
+ *     `Middleware` instance itself.
+ *  2. Custom presets previously registered via `Middleware.definePreset`
+ *     on the same instance.
+ *  3. Custom presets registered via the standalone `definePreset` here —
+ *     these are forwarded to the instance on demand.
+ *
+ * @param middleware the active `Middleware` provider (typically resolved from
+ *                   the DI container inside `configureServices()`)
+ * @param name       preset to apply
+ * @param overrides  optional partial config that is merged on top of the
+ *                   preset before application
+ *
+ * @public API
+ */
+export declare function applyPreset(middleware: Middleware, name: string, overrides?: Partial<MiddlewareConfig>): void;
+/**
+ * Returns the names of every preset registered through the standalone
+ * `definePreset` helper. Built-in presets and per-instance custom presets
+ * are NOT included — those live on the `Middleware` instance.
+ *
+ * @public API
+ */
+export declare function getStandalonePresetNames(): Array<string>;
+/**
+ * Remove every preset registered through the standalone `definePreset`
+ * helper. Useful in tests; rarely needed at runtime.
+ *
+ * @public API
+ */
+export declare function clearStandalonePresets(): void;

package/lib/esm/types/provider/db-in-memory/adapter/in-memory.adapter.d.ts

@@ -125,6 +125,8 @@ export interface InMemoryDatabaseOptions {
     timestamps?: boolean;
     /** Enable soft deletes by default for all tables */
     softDelete?: boolean;
+    /** Maximum number of records per table (0 = unlimited) */
+    maxRecordsPerTable?: number;
     /** Persistence configuration */
     persist?: {
         /** Storage type */

package/lib/esm/types/provider/db-in-memory/index.d.ts

@@ -4,6 +4,14 @@
  * A high-performance, Prisma-compatible in-memory database
  * for ExpressoTS applications.
  *
+ * Scope: this database is intended for development, testing, and
+ * prototyping. Data lives in process memory (with optional file
+ * snapshots) and does not provide the crash safety, concurrency, or
+ * multi-process guarantees of a real database engine. It implements the
+ * universal `IDataAdapter` contract so it can be swapped for a
+ * production adapter (Prisma, TypeORM, etc.) without rewriting
+ * repositories.
+ *
  * Features:
  * - Prisma-like query API
  * - Type-safe queries with TypeScript
@@ -56,7 +64,7 @@ export { InMemoryDBProvider, InMemoryDBConfig, BaseRepository, } from "./db.prov
 export { IDataAdapter, ITableAdapter, IMultiTableAdapter, IReactiveDataAdapter, ISubscription, ChangeEvent, ChangeType, InMemoryAdapter, InMemoryAdapterOptions, InMemoryDatabase, InMemoryDatabaseOptions, } from "./adapter/index.js";
 export { IEntity, ITimestampedEntity, ISoftDeleteEntity, Entity, EntityOptions, EntityMetadata, PrimaryKey, AutoGenerate, AutoGenerateStrategy, Index, IndexOptions, Unique, Nullable, Default, HasMany, HasOne, BelongsTo, ManyToMany, RelationType, RelationMetadata, SchemaRegistry, DB_METADATA_KEYS, } from "./schema/index.js";
 export { StringFilter, NumberFilter, BooleanFilter, DateFilter, FieldFilter, WhereInput, WhereUniqueInput, OrderByInput, SortOrder, SelectInput, IncludeInput, FindUniqueArgs, FindFirstArgs, FindManyArgs, CreateArgs, CreateInput, CreateManyArgs, UpdateArgs, UpdateInput, UpdateManyArgs, UpsertArgs, DeleteArgs, DeleteManyArgs, CountArgs, CountSelect, AggregateArgs, AggregateResult, NumericFieldsOnly, GroupByArgs, BatchPayload, TransactionClient, QueryEngine, } from "./query/index.js";
-export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./storage/index.js";
+export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./storage/index.js";
 export { IRepository, IDataTable, IDataProvider, } from "./db-in-memory.interface.js";
 export { InMemoryDataProvider, InMemoryDataTable, } from "./db-in-memory.provider.js";
 export { EntityNotFoundError as LegacyEntityNotFoundError, EntityAlreadyExistsError as LegacyEntityAlreadyExistsError, } from "./db-in-memory.types.js";

package/lib/esm/types/provider/db-in-memory/query/query-engine.d.ts

@@ -7,7 +7,7 @@
  */
 import { IEntity } from "../schema/entity.interface.js";
 import { MemoryStore } from "../storage/memory-store.js";
-import { WhereInput, OrderByInput, FindManyArgs, SelectInput, AggregateArgs, AggregateResult } from "./query.types.js";
+import { WhereInput, WhereUniqueInput, OrderByInput, FindManyArgs, SelectInput, AggregateArgs, AggregateResult } from "./query.types.js";
 /**
  * Query Engine for parsing and executing Prisma-like queries.
  *
@@ -72,6 +72,19 @@ export declare class QueryEngine<T extends IEntity> {
      * @returns Paginated entities
      */
     executePagination(entities: Array<T>, skip?: number, take?: number): Array<T>;
+    /**
+     * Apply cursor-based pagination. The cursor identifies a record (by id or
+     * any other field combination) within the ordered result set; the returned
+     * slice starts at that record. Combine with `skip` (typically `skip: 1` to
+     * exclude the cursor itself) and `take`.
+     *
+     * Should be applied after `orderBy` and before `skip`/`take`.
+     *
+     * @param entities - Ordered entities to slice
+     * @param cursor - Unique cursor identifying the start record
+     * @returns Entities starting at the cursor (empty array if not found)
+     */
+    executeCursor(entities: Array<T>, cursor?: WhereUniqueInput<T>): Array<T>;
     /**
      * Get distinct entities by specified fields.
      * @param entities - Entities to filter

package/lib/esm/types/provider/db-in-memory/schema/decorators.d.ts

@@ -306,6 +306,20 @@ export declare class SchemaRegistry {
      * @public API
      */
     static getRelations(target: new (...args: Array<unknown>) => unknown): Array<RelationMetadata>;
+    /**
+     * Get primary key field names for an entity.
+     * @param target - Entity class
+     * @returns Array of primary key field names
+     * @public API
+     */
+    static getPrimaryKeys(target: new (...args: Array<unknown>) => unknown): Array<string | symbol>;
+    /**
+     * Get nullable field names for an entity.
+     * @param target - Entity class
+     * @returns Array of nullable field names
+     * @public API
+     */
+    static getNullableFields(target: new (...args: Array<unknown>) => unknown): Array<string | symbol>;
     /**
      * Clear all registered entities (useful for testing).
      * @public API

package/lib/esm/types/provider/db-in-memory/storage/index.d.ts

@@ -2,4 +2,4 @@
  * Storage Module Exports
  * @module db-in-memory/storage
  */
-export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./memory-store.js";
+export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./memory-store.js";

package/lib/esm/types/provider/db-in-memory/storage/memory-store.d.ts

@@ -102,6 +102,24 @@ export declare class EntityNotFoundError extends Error {
     id: string;
     constructor(entityName: string, id: string);
 }
+/**
+ * Error thrown when a table reaches its configured record limit.
+ * @public API
+ */
+export declare class MaxRecordsExceededError extends Error {
+    tableName: string;
+    limit: number;
+    constructor(tableName: string, limit: number);
+}
+/**
+ * Error thrown when entity validation fails (when `@Entity({ validate: true })`).
+ * @public API
+ */
+export declare class EntityValidationError extends Error {
+    tableName: string;
+    field: string;
+    constructor(tableName: string, field: string, message?: string);
+}
 /**
  * Error thrown when an entity already exists.
  * @public API
@@ -143,6 +161,8 @@ export interface MemoryStoreOptions {
     timestamps?: boolean;
     /** Enable soft deletes */
     softDelete?: boolean;
+    /** Maximum number of records allowed in the table (0 = unlimited) */
+    maxRecordsPerTable?: number;
 }
 /**
  * High-performance in-memory storage for a single table/collection.
@@ -175,12 +195,26 @@ export declare class MemoryStore<T extends IEntity> {
     private autoGenerateFields;
     /** Default values */
     private defaultValues;
+    /** Maximum number of records allowed (0 = unlimited) */
+    private maxRecords;
+    /** Enable runtime validation (from @Entity({ validate: true })) */
+    private validate;
+    /** Fields that must be present and non-null when validation is enabled */
+    private requiredFields;
     constructor(tableName: string, options?: MemoryStoreOptions);
     /**
      * Load schema metadata from decorators.
      * @private
      */
     private loadSchemaMetadata;
+    /**
+     * Validate an entity against the schema (only when `validate` is enabled).
+     * Ensures required fields (primary key + unique, excluding @Nullable) are
+     * present and non-null.
+     * @private
+     * @throws ValidationError when a required field is missing or null
+     */
+    private validateEntity;
     /**
      * Apply auto-generation and defaults to entity.
      * @private

package/lib/esm/types/provider/logger/logger.banner.d.ts

@@ -72,7 +72,7 @@ export declare class BannerGenerator {
      */
     private displayFullBanner;
     /**
-     * Display compact banner.
+     * Display compact banner using structured log format (cloud-friendly).
      */
     private displayCompactBanner;
     /**

package/lib/esm/types/provider/logger/logger.config.d.ts

@@ -50,6 +50,13 @@ export interface LoggerConfig {
 }
 /**
  * Default logger configuration.
+ *
+ * Honours `process.env.LOG_LEVEL` when set so that any logs emitted
+ * BEFORE the application's `globalConfiguration()` runs (e.g. interceptor
+ * registration during container construction) are gated by the user's
+ * desired log level instead of the development default of `DEBUG`.
+ * Falls back to `DEBUG` in development and `INFO` in production.
+ *
  * @public API
  */
 export declare function getDefaultLoggerConfig(): LoggerConfig;

package/lib/esm/types/provider/logger/logger.formatter.d.ts

@@ -9,6 +9,16 @@ export interface FormatOptions {
     redact?: boolean;
     /** Custom redactor instance (uses global if not provided) */
     redactor?: Redactor;
+    /**
+     * Emit ANSI color escape codes. When false, the formatted output is
+     * post-processed to strip every ANSI escape. Defaults to true (colored).
+     *
+     * Disable this for non-TTY consumers like cloud log viewers (Azure
+     * App Service, AWS CloudWatch, Heroku, Kubernetes, etc.) and Studio's
+     * Live Logs panel, all of which display the raw text without
+     * interpreting terminal escape sequences.
+     */
+    colors?: boolean;
 }
 /**
  * Format log entry for development (human-readable, colored).

package/lib/esm/types/provider/logger/logger.provider.d.ts

@@ -12,7 +12,7 @@ import { LogQueryOptions, LogQuery, QueryStats } from "./logger.query.js";
  * - Automatic context detection (class/method names)
  * - Request-scoped context via AsyncLocalStorage
  * - Child logger creation with inherited context
- * - Multiple log levels (TRACE, DEBUG, INFO, WARN, ERROR, FATAL)
+ * - Multiple log levels (ALL, DEBUG, INFO, WARN, ERROR, FATAL, SILENT)
  * - Pluggable transports (console, file, HTTP)
  * @public API
  */
@@ -26,11 +26,42 @@ declare class Logger implements IProvider {
     private groupingManager;
     private healthMonitor;
     private queryManager;
+    /**
+     * Module-level overrides applied by `Logger.configure(...)` on top of the
+     * built-in defaults. Used by the constructor of every future `Logger`
+     * instance so application-wide config (e.g. log level, transports) can be
+     * set once before bootstrap, before any DI container exists.
+     */
+    private static defaultOverrides;
     name: string;
     version: string;
     author: string;
     repo: string;
     constructor();
+    /**
+     * Configure the default LoggerConfig used by every future `Logger`
+     * instance constructed in this process.
+     *
+     * Use this from application config files **before** bootstrap so the DI
+     * container's Logger picks up the correct level / transports / grouping /
+     * health / redaction settings without needing to inject and reconfigure it.
+     * Calls are merged: later calls override earlier ones, but unspecified
+     * keys keep their previously-set values.
+     *
+     * Already-constructed Logger instances are NOT mutated by this call —
+     * use the instance method `logger.configure(...)` to update a live one.
+     *
+     * @param config - Partial configuration to merge with the defaults.
+     * @public API
+     */
+    static configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Reset the module-level overrides set by `Logger.configure`. Useful in
+     * tests to undo cross-test pollution.
+     *
+     * @public API
+     */
+    static resetConfigure(): void;
     /**
      * Configure the logger.
      * @param config - Partial configuration to merge with defaults

package/lib/esm/types/provider/logger/transports/console.transport.d.ts

@@ -32,6 +32,13 @@ export declare class ConsoleTransport implements ILogTransport {
     });
     /**
      * Create a console transport optimized for development.
+     *
+     * Colors are auto-detected: they're emitted when stdout is a TTY
+     * (your terminal) and disabled when stdout is piped or captured by
+     * a cloud log collector (Azure App Service, AWS CloudWatch, Heroku,
+     * Docker, Kubernetes, etc.). Respects the standard `NO_COLOR` and
+     * `FORCE_COLOR` environment variables.
+     *
      * @param redact - Enable redaction (default: false for development)
      * @returns ConsoleTransport configured for development
      * @public API

package/lib/esm/types/provider/logger/utils/log-levels.d.ts

@@ -4,8 +4,8 @@
  * @public API
  */
 export declare enum LogLevel {
-    /** Ultra-detailed diagnostic information (function entry/exit) */
-    TRACE = 0,
+    /** Show all logs (ultra-detailed diagnostic information, function entry/exit) */
+    ALL = 0,
     /** Detailed diagnostic information for debugging */
     DEBUG = 1,
     /** General informational messages */
@@ -23,7 +23,7 @@ export declare enum LogLevel {
  * String representation of log levels for backward compatibility.
  * @public API
  */
-export type LogLevelString = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL" | "SILENT" | "NONE";
+export type LogLevelString = "ALL" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL" | "SILENT" | "NONE";
 /**
  * Legacy log level for backward compatibility.
  * Maps to INFO level.

package/lib/esm/types/provider/validation/adapters/index.d.ts

@@ -2,9 +2,12 @@
  * Validation Adapters
  * @module @expressots/core/validation/adapters
  *
- * Built-in adapters for validation libraries.
- * Additional adapters (Zod, Yup, Joi) available as separate packages:
- * - @expressots/validator-zod
- * - @expressots/validator-yup
+ * Built-in adapters for validation libraries. The validation libraries
+ * themselves (`class-validator`, `zod`, `yup`) are *optional peer
+ * dependencies* — install only the one(s) you actually use.
+ *
+ * Additional Joi adapter is on the roadmap.
  */
 export { ClassValidatorAdapter } from "./class-validator.adapter.js";
+export { ZodValidatorAdapter, createZodValidator } from "./zod.adapter.js";
+export { YupValidatorAdapter, createYupValidator } from "./yup.adapter.js";

package/lib/esm/types/provider/validation/adapters/yup.adapter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Yup Validation Adapter
+ * @module @expressots/core/validation
+ *
+ * Built-in adapter for the [yup](https://github.com/jquense/yup) validation
+ * library. `yup` is declared as an *optional* peer dependency: install it
+ * explicitly (`npm i yup`) to enable this adapter.
+ *
+ * @example
+ * ```ts
+ * import * as yup from "yup";
+ * import { validationRegistry, createYupValidator } from "@expressots/core";
+ *
+ * validationRegistry.register(createYupValidator());
+ *
+ * const CreateUserSchema = yup.object({
+ *   email: yup.string().email().required(),
+ *   age:   yup.number().integer().min(18).required(),
+ * });
+ *
+ * @controller("/users")
+ * class UsersController {
+ *   @Post("/")
+ *   create(@body(CreateUserSchema) input: yup.InferType<typeof CreateUserSchema>) {
+ *     // input is fully typed and validated
+ *   }
+ * }
+ * ```
+ */
+import { IValidationAdapter, ValidationOptions, ValidationResult } from "../validation.interface.js";
+/** Subset of yup's surface we depend on, structurally typed. */
+interface YupLikeSchema {
+    readonly __isYupSchema__?: boolean;
+    validate?(data: unknown, options?: YupOptions): Promise<unknown>;
+    validateSync?(data: unknown, options?: YupOptions): unknown;
+    cast?(data: unknown, options?: YupOptions): unknown;
+}
+interface YupOptions {
+    abortEarly?: boolean;
+    stripUnknown?: boolean;
+    context?: unknown;
+}
+/**
+ * Adapter for [yup](https://github.com/jquense/yup). Detects yup schemas at
+ * runtime by checking for the `__isYupSchema__` brand or the presence of a
+ * `validate` + `cast` method pair.
+ *
+ * @public API
+ */
+export declare class YupValidatorAdapter implements IValidationAdapter<YupLikeSchema> {
+    readonly name = "yup";
+    readonly priority = 80;
+    canHandle(schema: unknown): boolean;
+    validate(data: unknown, schema: YupLikeSchema, options?: ValidationOptions): Promise<ValidationResult>;
+    transform(data: unknown, schema: YupLikeSchema): Promise<unknown>;
+    private mapIssues;
+}
+/**
+ * Convenience factory matching the `createXxxValidator` naming used by the
+ * other adapters. Equivalent to `new YupValidatorAdapter()`.
+ *
+ * @public API
+ */
+export declare function createYupValidator(): YupValidatorAdapter;
+export {};

package/lib/esm/types/provider/validation/adapters/zod.adapter.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Zod Validation Adapter
+ * @module @expressots/core/validation
+ *
+ * Built-in adapter for the [zod](https://zod.dev) validation library.
+ * `zod` is declared as an *optional* peer dependency: install it explicitly
+ * (`npm i zod`) to enable this adapter; otherwise validation falls back to
+ * the next registered adapter.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { validationRegistry, ZodValidatorAdapter, createZodValidator } from "@expressots/core";
+ *
+ * validationRegistry.register(createZodValidator());
+ *
+ * const CreateUserSchema = z.object({
+ *   email: z.string().email(),
+ *   age:   z.number().int().min(18),
+ * });
+ *
+ * @controller("/users")
+ * class UsersController {
+ *   @Post("/")
+ *   create(@body(CreateUserSchema) input: z.infer<typeof CreateUserSchema>) {
+ *     // input is fully typed and validated
+ *   }
+ * }
+ * ```
+ */
+import { IValidationAdapter, ValidationOptions, ValidationResult } from "../validation.interface.js";
+/**
+ * Minimal structural typing for the subset of zod we actually call. We cannot
+ * import zod directly from core (it is an optional peer), but we type the
+ * schema we receive as `unknown` and refine via the runtime `canHandle` check.
+ */
+interface ZodLikeSchema {
+    readonly _def?: unknown;
+    parse?(data: unknown): unknown;
+    parseAsync?(data: unknown): Promise<unknown>;
+    safeParseAsync?(data: unknown): Promise<{
+        success: boolean;
+        data?: unknown;
+        error?: {
+            issues: Array<ZodIssue>;
+        };
+    }>;
+    safeParse?(data: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: {
+            issues: Array<ZodIssue>;
+        };
+    };
+}
+interface ZodIssue {
+    path: Array<string | number>;
+    message: string;
+    code?: string;
+    received?: unknown;
+}
+/**
+ * Adapter for [zod](https://zod.dev). Picks up any zod schema (`z.object`,
+ * `z.string`, ...) at runtime by structural detection — no compile-time
+ * dependency on `zod` is required.
+ *
+ * @public API
+ */
+export declare class ZodValidatorAdapter implements IValidationAdapter<ZodLikeSchema> {
+    readonly name = "zod";
+    readonly priority = 90;
+    canHandle(schema: unknown): boolean;
+    validate(data: unknown, schema: ZodLikeSchema, _options?: ValidationOptions): Promise<ValidationResult>;
+    transform(data: unknown, schema: ZodLikeSchema): Promise<unknown>;
+    private mapIssues;
+}
+/**
+ * Convenience factory matching the `createXxxValidator` naming used by the
+ * other adapters. Equivalent to `new ZodValidatorAdapter()`.
+ *
+ * @public API
+ */
+export declare function createZodValidator(): ZodValidatorAdapter;
+export {};

package/lib/esm/types/provider/validation/index.d.ts

@@ -16,4 +16,4 @@ export { ValidationRegistry } from "./validation-registry.js";
 export { SmartFieldDetector } from "./smart-field-detector.js";
 export { HelpfulErrorFormatter, type ErrorFormat, type FormattedErrorResponse, } from "./helpful-error-formatter.js";
 export { getParameterType, getAllParameterTypes, getClassProperties, hasClassValidatorDecorators, isZodSchema, isClassConstructor, detectSchemaType, type InferredTypeInfo, type InferredPropertyInfo, } from "./type-inference.js";
-export { ClassValidatorAdapter } from "./adapters/index.js";
+export { ClassValidatorAdapter, ZodValidatorAdapter, createZodValidator, YupValidatorAdapter, createYupValidator, } from "./adapters/index.js";

package/lib/esm/types/render/features/view-debugger.d.ts

@@ -27,6 +27,16 @@ export declare class ViewDebugger {
      * Handle the view preview endpoint.
      */
     private handlePreviewEndpoint;
+    /**
+     * Normalise the `view` route param across Express 4 and 5.
+     *
+     * Express 4 / path-to-regexp v6 captured `/__views/preview/:view(*)`
+     * as a single string. Express 5 / path-to-regexp v8 changed the
+     * named-splat capture to `string[]` (one entry per slash-separated
+     * segment). The view engine needs the slash-joined form, so we always
+     * collapse the array shape back to that.
+     */
+    private resolveViewParam;
     /**
      * Handle the view info endpoint.
      */