alepha 0.13.5 → 0.13.7

package/src/core/providers/TypeProvider.ts

@@ -24,29 +24,21 @@ import type {
   TUnion,
   TUnsafe,
 } from "typebox";
-import * as TypeBox from "typebox";
 import { Type } from "typebox";
 import type {
   TLocalizedValidationError,
   TLocalizedValidationMessageCallback,
 } from "typebox/error";
-import TypeBoxFormat from "typebox/format";
+import Format from "typebox/format";
 import { Locale } from "typebox/system";
-import * as TypeBoxValue from "typebox/value";
+import * as Value from "typebox/value";
 import { OPTIONS } from "../constants/OPTIONS.ts";
 import { AlephaError } from "../errors/AlephaError.ts";
 import type { TypeBoxError } from "../errors/TypeBoxError.ts";
 import { isTypeFile, type TFile, type TStream } from "../helpers/FileLike.ts";
 
-export { TypeBox, TypeBoxValue, TypeBoxFormat };
-
-export const isUUID = TypeBoxFormat.IsUuid;
-export const isEmail = TypeBoxFormat.IsEmail;
-export const isURL = TypeBoxFormat.IsUrl;
-export const isDateTime = TypeBoxFormat.IsDateTime;
-export const isDate = TypeBoxFormat.IsDate;
-export const isTime = TypeBoxFormat.IsTime;
-export const isDuration = TypeBoxFormat.IsDuration;
+export { Type, Value, Format };
+export const isUUID = Format.IsUuid;
 
 export type {
   StaticDecode,
@@ -82,26 +74,26 @@ export type {
 export class TypeGuard {
   // -------------------------------------------------------------------------------------------------------------------
   isBigInt = (value: TSchema): value is TString =>
-    TypeBox.IsString(value) && "format" in value && value.format === "bigint";
+    Type.IsString(value) && "format" in value && value.format === "bigint";
   isUUID = (value: TSchema): value is TString =>
-    TypeBox.IsString(value) && "format" in value && value.format === "uuid";
-  isObject = TypeBox.IsObject;
-  isNumber = TypeBox.IsNumber;
-  isString = TypeBox.IsString;
-  isBoolean = TypeBox.IsBoolean;
-  isAny = TypeBox.IsAny;
-  isArray = TypeBox.IsArray;
-  isOptional = TypeBox.IsOptional;
-  isUnion = TypeBox.IsUnion;
-  isInteger = TypeBox.IsInteger;
-  isNull = TypeBox.IsNull;
-  isUndefined = TypeBox.IsUndefined;
-  isUnsafe = TypeBox.IsUnsafe;
-  isRecord = TypeBox.IsRecord;
-  isTuple = TypeBox.IsTuple;
-  isVoid = TypeBox.IsVoid;
-  isLiteral = TypeBox.IsLiteral;
-  isSchema = TypeBox.IsSchema;
+    Type.IsString(value) && "format" in value && value.format === "uuid";
+  isObject = Type.IsObject;
+  isNumber = Type.IsNumber;
+  isString = Type.IsString;
+  isBoolean = Type.IsBoolean;
+  isAny = Type.IsAny;
+  isArray = Type.IsArray;
+  isOptional = Type.IsOptional;
+  isUnion = Type.IsUnion;
+  isInteger = Type.IsInteger;
+  isNull = Type.IsNull;
+  isUndefined = Type.IsUndefined;
+  isUnsafe = Type.IsUnsafe;
+  isRecord = Type.IsRecord;
+  isTuple = Type.IsTuple;
+  isVoid = Type.IsVoid;
+  isLiteral = Type.IsLiteral;
+  isSchema = Type.IsSchema;
   // -------------------------------------------------------------------------------------------------------------------
   isFile = isTypeFile;
   isDateTime = (schema: unknown) => {
@@ -131,10 +123,10 @@ declare module "typebox" {
 }
 
 export class TypeProvider {
-  static format = TypeBoxFormat;
+  static format = Format;
 
   static {
-    TypeBoxFormat.Set("bigint", (value: string | number) =>
+    Format.Set("bigint", (value: string | number) =>
       TypeProvider.isValidBigInt(value),
     );
   }
@@ -398,7 +390,7 @@ export class TypeProvider {
    * Create a schema for a JSON object.
    * This is a record with string keys and any values.
    */
-  public json(options?: TSchemaOptions): TRecord<string, TAny> {
+  public json<T = any>(options?: TSchemaOptions): TRecord<string, TAny> {
     return t.record(t.text(), t.any(), options);
   }
 

package/src/logger/index.ts

@@ -1,12 +1,13 @@
 import { $module, type Static, t } from "alepha";
 import { $logger } from "./primitives/$logger.ts";
+import { ConsoleColorProvider } from "./providers/ConsoleColorProvider.ts";
 import { ConsoleDestinationProvider } from "./providers/ConsoleDestinationProvider.ts";
 import { JsonFormatterProvider } from "./providers/JsonFormatterProvider.ts";
 import { LogDestinationProvider } from "./providers/LogDestinationProvider.ts";
 import { LogFormatterProvider } from "./providers/LogFormatterProvider.ts";
 import { MemoryDestinationProvider } from "./providers/MemoryDestinationProvider.ts";
+import { PrettyFormatterProvider } from "./providers/PrettyFormatterProvider.ts";
 import { RawFormatterProvider } from "./providers/RawFormatterProvider.ts";
-import { SimpleFormatterProvider } from "./providers/SimpleFormatterProvider.ts";
 import type { LogEntry } from "./schemas/logEntrySchema.ts";
 import { Logger } from "./services/Logger.ts";
 
@@ -19,7 +20,7 @@ export * from "./providers/JsonFormatterProvider.ts";
 export * from "./providers/LogDestinationProvider.ts";
 export * from "./providers/LogFormatterProvider.ts";
 export * from "./providers/MemoryDestinationProvider.ts";
-export * from "./providers/SimpleFormatterProvider.ts";
+export * from "./providers/PrettyFormatterProvider.ts";
 export * from "./schemas/logEntrySchema.ts";
 export * from "./services/Logger.ts";
 
@@ -101,8 +102,9 @@ export const AlephaLogger = $module({
     ConsoleDestinationProvider,
     MemoryDestinationProvider,
     JsonFormatterProvider,
-    SimpleFormatterProvider,
+    PrettyFormatterProvider,
     RawFormatterProvider,
+    ConsoleColorProvider,
   ],
   register: (alepha) => {
     const env = alepha.parseEnv(envSchema);
@@ -141,14 +143,14 @@ export const AlephaLogger = $module({
         if (env.LOG_FORMAT === "raw") {
           return RawFormatterProvider;
         }
-        return SimpleFormatterProvider;
+        return PrettyFormatterProvider;
       }
 
       if (alepha.isProduction() && !alepha.isBrowser()) {
         return JsonFormatterProvider;
       }
 
-      return SimpleFormatterProvider;
+      return PrettyFormatterProvider;
     };
 
     alepha.with({
@@ -202,7 +204,7 @@ const envSchema = t.object({
   /**
    * Built-in log formats.
    * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
-   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
+   * - "pretty" - Simple text format, human-readable, with colors. {@link PrettyFormatterProvider}
    * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
    */
   LOG_FORMAT: t.optional(

package/src/logger/primitives/$logger.ts

@@ -26,7 +26,7 @@ export const $logger = (options: LoggerPrimitiveOptions = {}): Logger => {
   return $inject(Logger, {
     lifetime: "transient",
     args: [
-      options.name ?? service?.name,
+      options.name ?? service?.name ?? "Func",
       module?.name ?? alepha.env.MODULE_NAME ?? "app",
     ],
   });

package/src/logger/providers/{SimpleFormatterProvider.ts → PrettyFormatterProvider.ts}

@@ -3,7 +3,7 @@ import type { LogEntry } from "../schemas/logEntrySchema.ts";
 import { ConsoleColorProvider } from "./ConsoleColorProvider.ts";
 import { LogFormatterProvider } from "./LogFormatterProvider.ts";
 
-export class SimpleFormatterProvider extends LogFormatterProvider {
+export class PrettyFormatterProvider extends LogFormatterProvider {
   protected color = $inject(ConsoleColorProvider);
   protected alepha = $inject(Alepha);
 
@@ -107,6 +107,15 @@ export class SimpleFormatterProvider extends LogFormatterProvider {
       return "";
     }
 
+    if (this.alepha.isViteDev()) {
+      // Node.js - try to fix stack trace with Vite SSR helper
+      // Actually, it works only because we have a global helper in viteAlephaDev.ts
+      const gl = globalThis as Record<string, unknown>;
+      if (typeof gl === "object" && typeof gl.ssrFixStacktrace === "function") {
+        gl.ssrFixStacktrace(error);
+      }
+    }
+
     let str = error.stack ?? error.message;
 
     const anyError = error as any;

package/src/orm/index.ts

@@ -10,7 +10,10 @@ import { NodePostgresProvider } from "./providers/drivers/NodePostgresProvider.t
 import { NodeSqliteProvider } from "./providers/drivers/NodeSqliteProvider.ts";
 import { PglitePostgresProvider } from "./providers/drivers/PglitePostgresProvider.ts";
 import { RepositoryProvider } from "./providers/RepositoryProvider.ts";
+import { PgJsonQueryManager } from "./services/PgJsonQueryManager.ts";
+import { PgRelationManager } from "./services/PgRelationManager.ts";
 import { PostgresModelBuilder } from "./services/PostgresModelBuilder.ts";
+import { QueryManager } from "./services/QueryManager.ts";
 import { Repository } from "./services/Repository.ts";
 import { SqliteModelBuilder } from "./services/SqliteModelBuilder.ts";
 
@@ -176,6 +179,9 @@ export const AlephaPostgres = $module({
     DrizzleKitProvider,
     RepositoryProvider,
     Repository,
+    PgRelationManager,
+    PgJsonQueryManager,
+    QueryManager,
   ],
   register: (alepha: Alepha) => {
     const env = alepha.parseEnv(

package/src/orm/services/PgRelationManager.ts

@@ -1,4 +1,4 @@
-import { type TObject, TypeBoxValue, t } from "alepha";
+import { type TObject, t, Value } from "alepha";
 import { getTableName, type SQL, sql } from "drizzle-orm";
 import type { PgSelectBase, PgTableWithColumns } from "drizzle-orm/pg-core";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
@@ -103,7 +103,7 @@ export class PgRelationManager {
     joins: PgJoin[],
     parentPath?: string,
   ): TObject {
-    const schema = TypeBoxValue.Clone(baseSchema) as TObject;
+    const schema = Value.Clone(baseSchema) as TObject;
 
     // Group joins by parent
     const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);

package/src/orm/services/PostgresModelBuilder.ts

@@ -279,6 +279,13 @@ export class PostgresModelBuilder extends ModelBuilder {
       return schema(key, value);
     }
 
+    const isTypeEnum = (value: any): value is { enum: any[] } =>
+      t.schema.isUnsafe(value) &&
+      "type" in value &&
+      value.type === "string" &&
+      "enum" in value &&
+      Array.isArray(value.enum);
+
     if (t.schema.isArray(value)) {
       if (t.schema.isObject(value.items)) {
         return schema(key, value);
@@ -298,16 +305,13 @@ export class PostgresModelBuilder extends ModelBuilder {
       if (t.schema.isBoolean(value.items)) {
         return pg.boolean(key).array();
       }
+      if (isTypeEnum(value.items)) {
+        return pg.text(key).array();
+      }
     }
 
     // Enum handling
-    if (
-      t.schema.isUnsafe(value) &&
-      "type" in value &&
-      value.type === "string" &&
-      "enum" in value &&
-      Array.isArray(value.enum)
-    ) {
+    if (isTypeEnum(value)) {
       if (!value.enum.every((it) => typeof it === "string")) {
         throw new AlephaError(
           `Enum for ${fieldName} must be an array of strings, got ${JSON.stringify(

package/src/orm/services/Repository.ts

@@ -546,13 +546,15 @@ export abstract class Repository<T extends TObject> {
   /**
    * Create many entities.
    *
+   * Inserts are batched in chunks of 1000 to avoid hitting database limits.
+   *
    * @param values The entities to create.
    * @param opts The statement options.
    * @returns The created entities.
    */
   public async createMany(
     values: Array<Static<TObjectInsert<T>>>,
-    opts: StatementOptions = {},
+    opts: StatementOptions & { batchSize?: number } = {},
   ): Promise<Static<T>[]> {
     if (values.length === 0) {
       return [];
@@ -563,19 +565,26 @@ export abstract class Repository<T extends TObject> {
       data: values,
     });
 
+    const batchSize = opts.batchSize ?? 1000;
+    const allEntities: Static<T>[] = [];
+
     try {
-      const entities = await this.rawInsert(opts)
-        .values(values.map((data) => this.cast(data, true)))
-        .returning(this.table)
-        .then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
+      for (let i = 0; i < values.length; i += batchSize) {
+        const batch = values.slice(i, i + batchSize);
+        const entities = await this.rawInsert(opts)
+          .values(batch.map((data) => this.cast(data, true)))
+          .returning(this.table)
+          .then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
+        allEntities.push(...entities);
+      }
 
       await this.alepha.events.emit("repository:create:after", {
         tableName: this.tableName,
         data: values,
-        entity: entities,
+        entity: allEntities,
       });
 
-      return entities;
+      return allEntities;
     } catch (error) {
       throw this.handleError(error, "Insert query has failed");
     }

package/src/orm/services/SqliteModelBuilder.ts

@@ -190,6 +190,16 @@ export class SqliteModelBuilder extends ModelBuilder {
       return pg.integer(key);
     }
 
+    if (t.schema.isBigInt(value)) {
+      if (PG_PRIMARY_KEY in value || PG_IDENTITY in value) {
+        return pg
+          .integer(key, { mode: "number" })
+          .primaryKey({ autoIncrement: true });
+      }
+
+      return pg.integer(key, { mode: "number" });
+    }
+
     if (t.schema.isNumber(value)) {
       if (PG_IDENTITY in value) {
         return pg

package/src/server/index.ts

@@ -22,9 +22,12 @@ import { ServerBodyParserProvider } from "./providers/ServerBodyParserProvider.t
 import { ServerLoggerProvider } from "./providers/ServerLoggerProvider.ts";
 import { ServerNotReadyProvider } from "./providers/ServerNotReadyProvider.ts";
 import { ServerProvider } from "./providers/ServerProvider.ts";
+import { ServerRouterProvider } from "./providers/ServerRouterProvider.ts";
 import { ServerTimingProvider } from "./providers/ServerTimingProvider.ts";
 import type { FetchOptions, HttpAction } from "./services/HttpClient.ts";
 import { HttpClient } from "./services/HttpClient.ts";
+import { ServerRequestParser } from "./services/ServerRequestParser.ts";
+import { UserAgentParser } from "./services/UserAgentParser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -132,6 +135,9 @@ export const AlephaServer = $module({
     ServerNotReadyProvider,
     ServerTimingProvider,
     HttpClient,
+    UserAgentParser,
+    ServerRequestParser,
+    ServerRouterProvider,
   ],
   register: (alepha: Alepha) => {
     if (!alepha.isServerless() && !alepha.isViteDev()) {

package/src/server/primitives/$action.ts

@@ -44,7 +44,16 @@ import {
  * - Automatic content-type handling (JSON, form-data, plain text)
  *
  * **URL Generation**
- * Actions are prefixed with `/api` by default (configurable via `SERVER_API_PREFIX`).
+ *
+ * **Important:** All `$action` paths are automatically prefixed with `/api`.
+ *
+ * ```ts
+ * $action({ path: "/users" })     // → GET /api/users
+ * $action({ path: "/users/:id" }) // → GET /api/users/:id
+ * $action({ path: "/hello" })     // → GET /api/hello
+ * ```
+ *
+ * This prefix is configurable via the `SERVER_API_PREFIX` environment variable.
  * HTTP method defaults to GET, or POST if body schema is provided.
  *
  * **Common Use Cases**

package/src/server/providers/ServerBodyParserProvider.ts

@@ -1,5 +1,6 @@
 import { ReadableStream as WebStream } from "node:stream/web";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+import type { TSchema } from "alepha";
 import { $env, $hook, $inject, Alepha, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { HttpError } from "../errors/HttpError.ts";
@@ -44,7 +45,11 @@ export class ServerBodyParserProvider {
 
       if (route.schema?.body) {
         try {
-          const body = await this.parse(stream, request.headers);
+          const body = await this.parse(
+            stream,
+            request.headers,
+            route.schema.body,
+          );
           if (body) {
             request.body = body;
           }
@@ -68,18 +73,19 @@ export class ServerBodyParserProvider {
   public async parse(
     stream: ReadableStream,
     headers: Record<string, string>,
+    schema: TSchema,
   ): Promise<object | string | undefined> {
     const contentType = headers["content-type"];
     const contentEncoding = headers["content-encoding"];
 
     if (!contentType) return undefined;
 
-    if (contentType.startsWith("application/json")) {
-      return this.parseJson(stream, contentEncoding);
+    if (contentType.startsWith("text/plain") || t.schema.isString(schema)) {
+      return this.parseText(stream, contentEncoding);
     }
 
-    if (contentType.startsWith("text/plain")) {
-      return this.parseText(stream, contentEncoding);
+    if (contentType.startsWith("application/json")) {
+      return this.parseJson(stream, contentEncoding);
     }
 
     if (contentType.startsWith("application/x-www-form-urlencoded")) {

package/src/server/providers/ServerRouterProvider.ts

@@ -391,13 +391,19 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     }
 
     if (route.schema?.body) {
-      try {
-        request.body = this.alepha.codec.decode(
-          route.schema.body,
-          request.body,
-        );
-      } catch (error) {
-        throw new ValidationError("Invalid request body", error);
+      if (t.schema.isString(route.schema.body)) {
+        if (typeof request.body !== "string") {
+          throw new ValidationError("Request body is not a string");
+        }
+      } else {
+        try {
+          request.body = this.alepha.codec.decode(
+            route.schema.body,
+            request.body,
+          );
+        } catch (error) {
+          throw new ValidationError("Invalid request body", error);
+        }
       }
     }
   }

package/src/server-auth/primitives/$auth.ts

@@ -261,6 +261,13 @@ export class AuthPrimitive extends Primitive<AuthPrimitiveOptions> {
     return this.options.name ?? this.config.propertyKey;
   }
 
+  public get realm(): RealmPrimitive | undefined {
+    if ("realm" in this.options) {
+      return this.options.realm;
+    }
+    return undefined;
+  }
+
   public get jwks_uri(): string {
     const jwks = this.oauth?.serverMetadata().jwks_uri;
     if (!jwks) {

package/src/server-auth/providers/ServerAuthProvider.ts

@@ -41,6 +41,7 @@ export class ServerAuthProvider {
     httpOnly: true,
     schema: t.object({
       provider: t.text(),
+      realm: t.optional(t.text()),
       codeVerifier: t.optional(t.text({ size: "long" })),
       redirectUri: t.optional(t.text({ size: "long" })),
       state: t.optional(t.text()),
@@ -163,7 +164,7 @@ export class ServerAuthProvider {
   protected async cookiesToTokens(
     cookies: Cookies,
   ): Promise<Tokens | undefined> {
-    const tokens = this.tokens.get({ cookies });
+    const tokens = this.getTokens(cookies);
     if (!tokens) {
       // no cookie, no tokens
       this.log.trace("No tokens found in cookies");
@@ -247,7 +248,7 @@ export class ServerAuthProvider {
       response: userinfoResponseSchema,
     },
     handler: async ({ user, headers, cookies }) => {
-      const tokens = this.tokens.get({ cookies });
+      const tokens = this.getTokens(cookies);
       if (tokens) {
         const provider = this.provider(tokens);
         if (!("realm" in provider.options)) {
@@ -323,6 +324,9 @@ export class ServerAuthProvider {
     schema: {
       query: t.object({
         provider: t.text(),
+        realm: t.optional(
+          t.text({ description: "Realm name for multi-realm setups" }),
+        ),
       }),
       body: t.object({
         username: t.text(),
@@ -331,7 +335,11 @@ export class ServerAuthProvider {
       response: tokenResponseSchema,
     },
     handler: async ({ query, body, cookies }) => {
-      const provider = this.provider(query);
+      const provider = this.provider({
+        provider: query.provider,
+        realm: query.realm,
+      });
+
       const realm = "realm" in provider.options && provider.options.realm;
       if (!realm) {
         throw new SecurityError(
@@ -348,6 +356,8 @@ export class ServerAuthProvider {
         );
       }
 
+      console.log("->", body);
+
       let user: UserAccount | undefined;
       try {
         user = await credentials.account(body);
@@ -392,11 +402,17 @@ export class ServerAuthProvider {
     schema: {
       query: t.object({
         provider: t.text(),
+        realm: t.optional(
+          t.text({ description: "Realm name for multi-realm setups" }),
+        ),
         redirect_uri: t.optional(t.text({ size: "rich" })),
       }),
     },
     handler: async ({ query, url, reply }) => {
-      const provider = this.provider(query);
+      const provider = this.provider({
+        provider: query.provider,
+        realm: query.realm,
+      });
       const oauth = provider.oauth;
       if (!oauth) {
         throw new SecurityError(
@@ -433,6 +449,7 @@ export class ServerAuthProvider {
           nonce: parameters.nonce,
           redirectUri: query.redirect_uri ?? "/",
           provider: query.provider,
+          realm: query.realm,
         });
 
         reply.redirect(buildAuthorizationUrl(oauth, parameters).toString());
@@ -456,6 +473,7 @@ export class ServerAuthProvider {
         codeVerifier,
         redirectUri: query.redirect_uri ?? "/",
         provider: query.provider,
+        realm: query.realm,
       });
 
       reply.redirect(buildAuthorizationUrl(oauth, parameters).toString());
@@ -543,7 +561,7 @@ export class ServerAuthProvider {
     },
     handler: async ({ query, reply, cookies }) => {
       const redirect = query.post_logout_redirect_uri ?? "/";
-      const tokens = this.tokens.get({ cookies });
+      const tokens = this.getTokens(cookies);
       if (!tokens) {
         reply.redirect(redirect);
         return;
@@ -603,17 +621,42 @@ export class ServerAuthProvider {
     },
   });
 
-  protected provider(opts: string | { provider: string }): AuthPrimitive {
+  /**
+   * Find an auth provider by name and optionally by realm.
+   * When realm is specified, it filters providers by both name and realm.
+   * This enables multi-realm setups where multiple providers share the same name (e.g., "credentials").
+   */
+  protected provider(
+    opts: string | { provider: string; realm?: string },
+  ): AuthPrimitive {
     const name = typeof opts === "string" ? opts : opts.provider;
-    const identity = this.identities.find((identity) => identity.name === name);
+    const realmName = typeof opts === "string" ? undefined : opts.realm;
+
+    const identity = this.identities.find((identity) => {
+      if (identity.name !== name) {
+        return false;
+      }
+
+      // If realm filter is specified, match against provider's realm
+      if (realmName && identity.realm?.name !== realmName) {
+        return false;
+      }
+
+      return true;
+    });
 
     if (!identity) {
-      throw new SecurityError(`Auth provider '${name}' not found`);
+      const realmInfo = realmName ? ` for realm '${realmName}'` : "";
+      throw new SecurityError(`Auth provider '${name}'${realmInfo} not found`);
     }
 
     return identity;
   }
 
+  protected getTokens(cookies?: Cookies): Tokens | undefined {
+    return this.tokens.get({ cookies });
+  }
+
   protected setTokens(tokens: Tokens, cookies?: Cookies): void {
     const exp =
       tokens.refresh_token_expires_in ||

package/src/server-cookies/index.ts

@@ -2,6 +2,7 @@ import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
 import { $cookie, type Cookies } from "./primitives/$cookie.ts";
 import { ServerCookiesProvider } from "./providers/ServerCookiesProvider.ts";
+import { CookieParser } from "./services/CookieParser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -29,5 +30,5 @@ declare module "alepha/server" {
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
   primitives: [$cookie],
-  services: [AlephaServer, ServerCookiesProvider],
+  services: [AlephaServer, ServerCookiesProvider, CookieParser],
 });

package/src/thread/primitives/$thread.ts

@@ -1,7 +1,7 @@
 import { cpus } from "node:os";
 import { MessageChannel, type MessagePort, Worker } from "node:worker_threads";
 import type { TSchema } from "alepha";
-import { createPrimitive, KIND, Primitive, TypeBoxValue } from "alepha";
+import { createPrimitive, KIND, Primitive, Value } from "alepha";
 
 /**
  * Creates a worker thread primitive for offloading CPU-intensive tasks to separate threads.
@@ -244,7 +244,7 @@ export class ThreadPrimitive extends Primitive<ThreadPrimitiveOptions> {
   public async execute<T = any>(data?: any, schema?: TSchema): Promise<T> {
     if (schema && data) {
       try {
-        TypeBoxValue.Decode(schema, data);
+        Value.Decode(schema, data);
       } catch (error) {
         throw new Error(
           `Invalid data: ${error instanceof Error ? error.message : error}`,

package/src/vite/index.ts

@@ -1,7 +1,5 @@
 import type { Alepha } from "alepha";
 
-// Vite re-exports
-export { defineConfig } from "vite";
 // Helpers (for advanced use)
 export * from "./helpers/boot.ts";
 export * from "./helpers/createBufferedLogger.ts";