alepha 0.13.1 → 0.13.3

package/src/server/index.ts

@@ -1,11 +1,5 @@
 import type { Server } from "node:http";
-import { $module, type Alepha, type DescriptorFactoryLike } from "alepha";
-import {
-  $action,
-  type ActionDescriptor,
-  type ClientRequestOptions,
-} from "./descriptors/$action.ts";
-import { $route } from "./descriptors/$route.ts";
+import { $module, type Alepha, type PrimitiveFactoryLike } from "alepha";
 import type { HttpError } from "./errors/HttpError.ts";
 import type {
   NodeRequestEvent,
@@ -16,6 +10,12 @@ import type {
   ServerRoute,
   WebRequestEvent,
 } from "./interfaces/ServerRequest.ts";
+import {
+  $action,
+  type ActionPrimitive,
+  type ClientRequestOptions,
+} from "./primitives/$action.ts";
+import { $route } from "./primitives/$route.ts";
 import { BunHttpServerProvider } from "./providers/BunHttpServerProvider.ts";
 import { NodeHttpServerProvider } from "./providers/NodeHttpServerProvider.ts";
 import { ServerBodyParserProvider } from "./providers/ServerBodyParserProvider.ts";
@@ -36,12 +36,12 @@ declare module "alepha" {
     // -----------------------------------------------------------------------------------------------------------------
     // Local Actions hooks
     "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
     };
     "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
       response: any;
@@ -96,9 +96,9 @@ declare module "alepha" {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$action.ts";
-export * from "./descriptors/$route.ts";
 export * from "./index.shared.ts";
+export * from "./primitives/$action.ts";
+export * from "./primitives/$route.ts";
 export * from "./providers/BunHttpServerProvider.ts";
 export * from "./providers/NodeHttpServerProvider.ts";
 export * from "./providers/ServerLoggerProvider.ts";
@@ -110,9 +110,9 @@ export * from "./providers/ServerTimingProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Provides high-performance HTTP server capabilities with declarative routing and action descriptors.
+ * Provides high-performance HTTP server capabilities with declarative routing and action primitives.
  *
- * The server module enables building REST APIs and web applications using `$route` and `$action` descriptors
+ * The server module enables building REST APIs and web applications using `$route` and `$action` primitives
  * on class properties. It provides automatic request/response handling, schema validation, middleware support,
  * and seamless integration with other Alepha modules for a complete backend solution.
  *
@@ -122,7 +122,7 @@ export * from "./providers/ServerTimingProvider.ts";
  */
 export const AlephaServer = $module({
   name: "alepha.server",
-  descriptors: [$route, $action as DescriptorFactoryLike],
+  primitives: [$route, $action as PrimitiveFactoryLike],
   services: [
     ServerProvider,
     BunHttpServerProvider,

package/src/server/{descriptors → primitives}/$action.ts

@@ -2,10 +2,10 @@ import {
   $env,
   $inject,
   type Async,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   isTypeFile,
   KIND,
+  Primitive,
   type Static,
   type TObject,
   type TSchema,
@@ -30,7 +30,7 @@ import {
 } from "../services/HttpClient.ts";
 
 /**
- * Creates a server action descriptor for defining type-safe HTTP endpoints.
+ * Creates a server action primitive for defining type-safe HTTP endpoints.
  *
  * Server actions are the core building blocks for REST APIs in Alepha, providing declarative
  * HTTP endpoints with full type safety, automatic validation, and OpenAPI documentation.
@@ -95,9 +95,9 @@ import {
  * ```
  */
 export const $action = <TConfig extends RequestConfigSchema>(
-  options: ActionDescriptorOptions<TConfig>,
-): ActionDescriptorFn<TConfig> => {
-  const instance = createDescriptor(ActionDescriptor<TConfig>, options);
+  options: ActionPrimitiveOptions<TConfig>,
+): ActionPrimitiveFn<TConfig> => {
+  const instance = createPrimitive(ActionPrimitive<TConfig>, options);
   const fn = (
     config?: ClientRequestEntry<TConfig>,
     options?: ClientRequestOptions,
@@ -109,12 +109,12 @@ export const $action = <TConfig extends RequestConfigSchema>(
       return instance.options.name || instance.config.propertyKey;
     },
   });
-  return Object.setPrototypeOf(fn, instance) as ActionDescriptorFn<TConfig>;
+  return Object.setPrototypeOf(fn, instance) as ActionPrimitiveFn<TConfig>;
 };
 
 // ----------------------------------------------------------------------------------------------------------
 
-export interface ActionDescriptorOptions<TConfig extends RequestConfigSchema>
+export interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema>
   extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
@@ -198,9 +198,9 @@ const envSchema = t.object({
   }),
 });
 
-export class ActionDescriptor<
+export class ActionPrimitive<
   TConfig extends RequestConfigSchema,
-> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+> extends Primitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log = $logger();
   protected readonly env = $env(envSchema);
   protected readonly httpClient = $inject(HttpClient);
@@ -416,15 +416,15 @@ export class ActionDescriptor<
   }
 }
 
-export interface ActionDescriptorFn<TConfig extends RequestConfigSchema>
-  extends ActionDescriptor<TConfig> {
+export interface ActionPrimitiveFn<TConfig extends RequestConfigSchema>
+  extends ActionPrimitive<TConfig> {
   (
     config?: ClientRequestEntry<TConfig>,
     options?: ClientRequestOptions,
   ): Promise<ClientRequestResponse<TConfig>>;
 }
 
-$action[KIND] = ActionDescriptor;
+$action[KIND] = ActionPrimitive;
 
 // ----------------------------------------------------------------------------------------------------------
 

package/src/server/{descriptors → primitives}/$route.ts

@@ -1,4 +1,4 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type {
   RequestConfigSchema,
   ServerRoute,
@@ -8,28 +8,28 @@ import { ServerRouterProvider } from "../providers/ServerRouterProvider.ts";
 /**
  * Create a basic endpoint.
  *
- * It's a low level descriptor. You probably want to use `$action` instead.
+ * It's a low level primitive. You probably want to use `$action` instead.
  *
  * @see {@link $action}
  * @see {@link $page}
  */
 export const $route = <TConfig extends RequestConfigSchema>(
-  options: RouteDescriptorOptions<TConfig>,
-): RouteDescriptor<TConfig> => {
-  return createDescriptor(RouteDescriptor<TConfig>, options);
+  options: RoutePrimitiveOptions<TConfig>,
+): RoutePrimitive<TConfig> => {
+  return createPrimitive(RoutePrimitive<TConfig>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface RouteDescriptorOptions<
+export interface RoutePrimitiveOptions<
   TConfig extends RequestConfigSchema = RequestConfigSchema,
 > extends ServerRoute<TConfig> {}
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class RouteDescriptor<
+export class RoutePrimitive<
   TConfig extends RequestConfigSchema,
-> extends Descriptor<RouteDescriptorOptions<TConfig>> {
+> extends Primitive<RoutePrimitiveOptions<TConfig>> {
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
 
   protected onInit() {
@@ -37,4 +37,4 @@ export class RouteDescriptor<
   }
 }
 
-$route[KIND] = RouteDescriptor;
+$route[KIND] = RoutePrimitive;

package/src/server/providers/NodeHttpServerProvider.ts

@@ -57,7 +57,7 @@ export class NodeHttpServerProvider extends ServerProvider {
     on: "start",
     handler: async () => {
       await this.listen();
-      this.alepha.state.set("alepha.node.server", this.server);
+      this.alepha.store.set("alepha.node.server", this.server);
     },
   });
 

package/src/server/services/HttpClient.ts

@@ -10,7 +10,6 @@ import {
 import { $cache } from "alepha/cache";
 import type { DurationLike } from "alepha/datetime";
 import { $logger } from "alepha/logger";
-import type { ClientRequestOptions } from "../descriptors/$action.ts";
 import { HttpError } from "../errors/HttpError.ts";
 import { isMultipart } from "../helpers/isMultipart.ts";
 import type {
@@ -18,6 +17,7 @@ import type {
   TRequestBody,
   TResponseBody,
 } from "../interfaces/ServerRequest.ts";
+import type { ClientRequestOptions } from "../primitives/$action.ts";
 import { errorSchema } from "../schemas/errorSchema.ts";
 
 export class HttpClient {

package/src/server-auth/index.browser.ts

@@ -8,6 +8,6 @@ export * from "./index.shared.ts";
 
 export const AlephaServerAuth = $module({
   name: "alepha.server.auth",
-  descriptors: [],
+  primitives: [],
   services: [],
 });

package/src/server-auth/index.ts

@@ -1,16 +1,16 @@
 import { $module } from "alepha";
 import type { UserAccount } from "alepha/security";
 import { AlephaServerCookies } from "alepha/server/cookies";
-import { $auth } from "./descriptors/$auth.ts";
+import { $auth } from "./primitives/$auth.ts";
 import { ServerAuthProvider } from "./providers/ServerAuthProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$auth.ts";
-export * from "./descriptors/$authCredentials.ts";
-export * from "./descriptors/$authGithub.ts";
-export * from "./descriptors/$authGoogle.ts";
 export * from "./index.shared.ts";
+export * from "./primitives/$auth.ts";
+export * from "./primitives/$authCredentials.ts";
+export * from "./primitives/$authGithub.ts";
+export * from "./primitives/$authGoogle.ts";
 export * from "./providers/ServerAuthProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -43,6 +43,6 @@ declare module "alepha" {
  */
 export const AlephaServerAuth = $module({
   name: "alepha.server.auth",
-  descriptors: [$auth],
+  primitives: [$auth],
   services: [AlephaServerCookies, ServerAuthProvider],
 });

package/src/server-auth/{descriptors → primitives}/$auth.ts

@@ -2,14 +2,14 @@ import {
   $inject,
   AlephaError,
   type Async,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
 } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import {
   type AccessTokenResponse,
-  type RealmDescriptor,
+  type RealmPrimitive,
   SecurityError,
   SecurityProvider,
   type UserAccount,
@@ -24,7 +24,7 @@ import type { OAuth2Profile } from "../providers/ServerAuthProvider.ts";
 import type { Tokens } from "../schemas/tokensSchema.ts";
 
 /**
- * Creates an authentication provider descriptor for handling user login flows.
+ * Creates an authentication provider primitive for handling user login flows.
  *
  * Supports multiple authentication strategies: credentials (username/password), OAuth2,
  * and OIDC (OpenID Connect). Handles token management, user profile retrieval, and
@@ -57,13 +57,13 @@ import type { Tokens } from "../schemas/tokensSchema.ts";
  * }
  * ```
  */
-export const $auth = (options: AuthDescriptorOptions): AuthDescriptor => {
-  return createDescriptor(AuthDescriptor, options);
+export const $auth = (options: AuthPrimitiveOptions): AuthPrimitive => {
+  return createPrimitive(AuthPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export type AuthDescriptorOptions = {
+export type AuthPrimitiveOptions = {
   /**
    * Name of the identity provider.
    * If not provided, it will be derived from the property key.
@@ -108,7 +108,7 @@ export type AuthExternal = {
  * This relies on the `realm`, which is used to create/verify the access token.
  */
 export type AuthInternal = {
-  realm: RealmDescriptor;
+  realm: RealmPrimitive;
 } & (
   | {
       /**
@@ -251,7 +251,7 @@ export interface OAuth2Options {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
+export class AuthPrimitive extends Primitive<AuthPrimitiveOptions> {
   protected readonly securityProvider = $inject(SecurityProvider);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
 
@@ -433,7 +433,7 @@ export class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
   }
 }
 
-$auth[KIND] = AuthDescriptor;
+$auth[KIND] = AuthPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/server-auth/{descriptors → primitives}/$authCredentials.ts

@@ -1,5 +1,5 @@
 import { AlephaError } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import {
   $auth,
   type CredentialsFn,
@@ -8,12 +8,12 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured Credentials authentication descriptor.
+ * Already configured Credentials authentication primitive.
  *
  * Uses username and password to authenticate users.
  */
 export const $authCredentials = (
-  realm: RealmDescriptor & WithLoginFn,
+  realm: RealmPrimitive & WithLoginFn,
   options: Partial<CredentialsOptions> = {},
 ) => {
   const name = "credentials";
@@ -24,7 +24,7 @@ export const $authCredentials = (
 
   if (!account) {
     throw new AlephaError(
-      "Credentials authentication requires a login function in the realm descriptor.",
+      "Credentials authentication requires a login function in the realm primitive.",
     );
   }
 

package/src/server-auth/{descriptors → primitives}/$authGithub.ts

@@ -1,5 +1,5 @@
 import { $context, AlephaError, t } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import type { OAuth2Profile } from "../providers/ServerAuthProvider.ts";
 import {
   $auth,
@@ -9,7 +9,7 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured GitHub authentication descriptor.
+ * Already configured GitHub authentication primitive.
  *
  * Uses OAuth2 to authenticate users via their GitHub accounts.
  * Upon successful authentication, it links the GitHub account to a user session.
@@ -19,7 +19,7 @@ import {
  * - `GITHUB_CLIENT_SECRET`: The client secret obtained from the GitHub Developer Settings.
  */
 export const $authGithub = (
-  realm: RealmDescriptor & WithLinkFn,
+  realm: RealmPrimitive & WithLinkFn,
   options: Partial<OidcOptions> = {},
 ) => {
   const { alepha } = $context();
@@ -40,7 +40,7 @@ export const $authGithub = (
 
   if (!account) {
     throw new AlephaError(
-      "Authentication requires a link function in the realm descriptor.",
+      "Authentication requires a link function in the realm primitive.",
     );
   }
 

package/src/server-auth/{descriptors → primitives}/$authGoogle.ts

@@ -1,5 +1,5 @@
 import { $context, AlephaError, t } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import {
   $auth,
   type LinkAccountFn,
@@ -8,7 +8,7 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured Google authentication descriptor.
+ * Already configured Google authentication primitive.
  *
  * Uses OpenID Connect (OIDC) to authenticate users via their Google accounts.
  * Upon successful authentication, it links the Google account to a user session.
@@ -18,7 +18,7 @@ import {
  * - `GOOGLE_CLIENT_SECRET`: The client secret obtained from the Google Developer Console.
  */
 export const $authGoogle = (
-  realm: RealmDescriptor & WithLinkFn,
+  realm: RealmPrimitive & WithLinkFn,
   options: Partial<OidcOptions> = {},
 ) => {
   const { alepha } = $context();
@@ -39,7 +39,7 @@ export const $authGoogle = (
 
   if (!account) {
     throw new AlephaError(
-      "Authentication requires a link function in the realm descriptor.",
+      "Authentication requires a link function in the realm primitive.",
     );
   }
 

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

@@ -22,7 +22,7 @@ import {
   randomState,
 } from "openid-client";
 import { alephaServerAuthRoutes } from "../constants/routes.ts";
-import { $auth, type AuthDescriptor } from "../descriptors/$auth.ts";
+import { $auth, type AuthPrimitive } from "../primitives/$auth.ts";
 import type { AuthenticationProvider } from "../schemas/authenticationProviderSchema.ts";
 import { tokenResponseSchema } from "../schemas/tokenResponseSchema.ts";
 import { type Tokens, tokensSchema } from "../schemas/tokensSchema.ts";
@@ -57,9 +57,9 @@ export class ServerAuthProvider {
     schema: tokensSchema,
   });
 
-  public get identities(): Array<AuthDescriptor> {
+  public get identities(): Array<AuthPrimitive> {
     return this.alepha
-      .descriptors($auth)
+      .primitives($auth)
       .filter((auth) => !auth.options.disabled);
   }
 
@@ -603,7 +603,7 @@ export class ServerAuthProvider {
     },
   });
 
-  protected provider(opts: string | { provider: string }): AuthDescriptor {
+  protected provider(opts: string | { provider: string }): AuthPrimitive {
     const name = typeof opts === "string" ? opts : opts.provider;
     const identity = this.identities.find((identity) => identity.name === name);
 

package/src/server-cache/providers/ServerCacheProvider.ts

@@ -1,11 +1,11 @@
 import type { BinaryLike } from "node:crypto";
 import { createHash } from "node:crypto";
 import { $hook, $inject, Alepha } from "alepha";
-import { $cache, type CacheDescriptorOptions } from "alepha/cache";
+import { $cache, type CachePrimitiveOptions } from "alepha/cache";
 import { DateTimeProvider, type DurationLike } from "alepha/datetime";
 import { $logger } from "alepha/logger";
 import {
-  ActionDescriptor,
+  ActionPrimitive,
   type RequestConfigSchema,
   type ServerRequest,
   type ServerRoute,
@@ -25,13 +25,13 @@ declare module "alepha/server" {
     cache?: ServerRouteCache;
   }
 
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
+  interface ActionPrimitive<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
   }
 }
 
-ActionDescriptor.prototype.invalidate = async function (
-  this: ActionDescriptor<RequestConfigSchema>,
+ActionPrimitive.prototype.invalidate = async function (
+  this: ActionPrimitive<RequestConfigSchema>,
 ) {
   await this.alepha.inject(ServerCacheProvider).invalidate(this.route);
 };
@@ -422,11 +422,11 @@ export type ServerRouteCache =
       /**
        * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
        * If a DurationLike is provided, it will be used as the TTL for the cache.
-       * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
+       * If CachePrimitiveOptions is provided, it will be used to configure the cache storage.
        *
        * @default false
        */
-      store?: true | DurationLike | CacheDescriptorOptions;
+      store?: true | DurationLike | CachePrimitiveOptions;
       /**
        * If true, enables ETag support for the cached responses.
        */

package/src/server-compress/providers/ServerCompressProvider.ts

@@ -2,7 +2,7 @@ import { Readable, type Transform } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
-import { $hook, $inject, Alepha, type HookDescriptor } from "alepha";
+import { $hook, $inject, Alepha } from "alepha";
 import type { ServerResponse } from "alepha/server";
 
 const gzip = promisify(zlib.gzip);
@@ -55,11 +55,11 @@ export class ServerCompressProvider {
         "text/plain",
         "text/css",
       ],
-      ...this.alepha.state.get("alepha.server.compress.options"),
+      ...this.alepha.store.get("alepha.server.compress.options"),
     };
   }
 
-  public readonly onResponse: HookDescriptor<"server:onResponse"> = $hook({
+  public readonly onResponse = $hook({
     on: "server:onResponse",
     handler: async ({ request, response }) => {
       // skip if already compressed

package/src/server-cookies/index.browser.ts

@@ -3,12 +3,12 @@ import { AlephaServer } from "alepha/server";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cookie.browser.ts";
+export * from "./primitives/$cookie.browser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
-  descriptors: [],
+  primitives: [],
   services: [AlephaServer],
 });

package/src/server-cookies/index.ts

@@ -1,11 +1,11 @@
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $cookie, type Cookies } from "./descriptors/$cookie.ts";
+import { $cookie, type Cookies } from "./primitives/$cookie.ts";
 import { ServerCookiesProvider } from "./providers/ServerCookiesProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cookie.ts";
+export * from "./primitives/$cookie.ts";
 export * from "./providers/ServerCookiesProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -17,9 +17,9 @@ declare module "alepha/server" {
 }
 
 /**
- * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie primitives.
  *
- * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * The server-cookies module enables declarative cookie handling using the `$cookie` primitive on class properties.
  * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
  * for managing user sessions, preferences, and authentication tokens.
  *
@@ -28,6 +28,6 @@ declare module "alepha/server" {
  */
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
-  descriptors: [$cookie],
+  primitives: [$cookie],
   services: [AlephaServer, ServerCookiesProvider],
 });

package/src/server-cookies/{descriptors → primitives}/$cookie.browser.ts

@@ -2,23 +2,23 @@ import {
   $inject,
   Alepha,
   AlephaError,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   type TSchema,
 } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { CookieParser } from "../services/CookieParser.ts";
 import type {
-  AbstractCookieDescriptor,
+  AbstractCookiePrimitive,
   Cookie,
-  CookieDescriptorOptions,
+  CookiePrimitiveOptions,
   Cookies,
 } from "./$cookie.ts";
 
 /**
- * Creates a browser-side cookie descriptor for client-side cookie management.
+ * Creates a browser-side cookie primitive for client-side cookie management.
  *
  * Browser-specific version of $cookie that uses document.cookie API. Supports type-safe
  * cookie operations with schema validation but excludes encryption/signing (use server-side
@@ -46,16 +46,16 @@ import type {
  * ```
  */
 export const $cookie = <T extends TSchema>(
-  options: CookieDescriptorOptions<T>,
-): AbstractCookieDescriptor<T> => {
-  return createDescriptor(BrowserCookieDescriptor<T>, options);
+  options: CookiePrimitiveOptions<T>,
+): AbstractCookiePrimitive<T> => {
+  return createPrimitive(BrowserCookiePrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class BrowserCookieDescriptor<T extends TSchema>
-  extends Descriptor<CookieDescriptorOptions<T>>
-  implements AbstractCookieDescriptor<T>
+export class BrowserCookiePrimitive<T extends TSchema>
+  extends Primitive<CookiePrimitiveOptions<T>>
+  implements AbstractCookiePrimitive<T>
 {
   protected cookieParser = $inject(CookieParser);
   protected alepha = $inject(Alepha);
@@ -143,4 +143,4 @@ export class BrowserCookieDescriptor<T extends TSchema>
   }
 }
 
-$cookie[KIND] = BrowserCookieDescriptor;
+$cookie[KIND] = BrowserCookiePrimitive;