alepha 0.13.1 → 0.13.3

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

@@ -1,8 +1,8 @@
 import {
   $inject,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   type TSchema,
 } from "alepha";
@@ -11,18 +11,18 @@ import { ServerCookiesProvider } from "../providers/ServerCookiesProvider.ts";
 
 /**
  * Declares a type-safe, configurable HTTP cookie.
- * This descriptor provides methods to get, set, and delete the cookie
+ * This primitive provides methods to get, set, and delete the cookie
  * within the server request/response cycle.
  */
 export const $cookie = <T extends TSchema>(
-  options: CookieDescriptorOptions<T>,
-): AbstractCookieDescriptor<T> => {
-  return createDescriptor(CookieDescriptor<T>, options);
+  options: CookiePrimitiveOptions<T>,
+): AbstractCookiePrimitive<T> => {
+  return createPrimitive(CookiePrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface CookieDescriptorOptions<T extends TSchema> {
+export interface CookiePrimitiveOptions<T extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
   schema: T;
 
@@ -57,9 +57,9 @@ export interface CookieDescriptorOptions<T extends TSchema> {
   sign?: boolean;
 }
 
-export interface AbstractCookieDescriptor<T extends TSchema> {
+export interface AbstractCookiePrimitive<T extends TSchema> {
   readonly name: string;
-  readonly options: CookieDescriptorOptions<T>;
+  readonly options: CookiePrimitiveOptions<T>;
   set(
     value: Static<T>,
     options?: { cookies?: Cookies; ttl?: DurationLike },
@@ -68,9 +68,9 @@ export interface AbstractCookieDescriptor<T extends TSchema> {
   del(options?: { cookies?: Cookies }): void;
 }
 
-export class CookieDescriptor<T extends TSchema>
-  extends Descriptor<CookieDescriptorOptions<T>>
-  implements AbstractCookieDescriptor<T>
+export class CookiePrimitive<T extends TSchema>
+  extends Primitive<CookiePrimitiveOptions<T>>
+  implements AbstractCookiePrimitive<T>
 {
   protected readonly serverCookiesProvider = $inject(ServerCookiesProvider);
 
@@ -119,7 +119,7 @@ export class CookieDescriptor<T extends TSchema>
   }
 }
 
-$cookie[KIND] = CookieDescriptor;
+$cookie[KIND] = CookiePrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/server-cookies/providers/ServerCookiesProvider.ts

@@ -11,6 +11,7 @@ import {
   $hook,
   $inject,
   Alepha,
+  AlephaError,
   type Static,
   type TSchema,
   t,
@@ -21,9 +22,9 @@ import { DEFAULT_APP_SECRET } from "alepha/security";
 import type { ServerRequest } from "alepha/server";
 import type {
   Cookie,
-  CookieDescriptorOptions,
+  CookiePrimitiveOptions,
   Cookies,
-} from "../descriptors/$cookie.ts";
+} from "../primitives/$cookie.ts";
 import { CookieParser } from "../services/CookieParser.ts";
 
 const envSchema = t.object({
@@ -89,14 +90,14 @@ export class ServerCookiesProvider {
       this.alepha.context.get<ServerRequest>("request")?.cookies;
     if (cookies) return cookies;
     if (contextCookies) return contextCookies;
-    throw new Error(
+    throw new AlephaError(
       "Cookie context is not available. This method must be called within a server request cycle.",
     );
   }
 
   public getCookie<T extends TSchema>(
     name: string,
-    options: CookieDescriptorOptions<T>,
+    options: CookiePrimitiveOptions<T>,
     contextCookies?: Cookies,
   ): Static<T> | undefined {
     const cookies = this.getCookiesFromContext(contextCookies);
@@ -145,7 +146,7 @@ export class ServerCookiesProvider {
 
   public setCookie<T extends TSchema>(
     name: string,
-    options: CookieDescriptorOptions<T>,
+    options: CookiePrimitiveOptions<T>,
     data: Static<T>,
     contextCookies?: Cookies,
   ): void {

package/src/server-cookies/services/CookieParser.ts

@@ -1,4 +1,4 @@
-import type { Cookie } from "../descriptors/$cookie.ts";
+import type { Cookie } from "../primitives/$cookie.ts";
 
 export class CookieParser {
   public parseRequestCookies(header: string): Record<string, string> {

package/src/server-cors/index.ts

@@ -1,5 +1,5 @@
 import { $module } from "alepha";
-import { $cors } from "./descriptors/$cors.ts";
+import { $cors } from "./primitives/$cors.ts";
 import {
   type CorsOptions,
   ServerCorsProvider,
@@ -7,7 +7,7 @@ import {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cors.ts";
+export * from "./primitives/$cors.ts";
 export * from "./providers/ServerCorsProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -52,6 +52,6 @@ declare module "alepha/server" {
  */
 export const AlephaServerCors = $module({
   name: "alepha.server.cors",
-  descriptors: [$cors],
+  primitives: [$cors],
   services: [ServerCorsProvider],
 });

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

@@ -1,10 +1,10 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type { CorsOptions } from "../providers/ServerCorsProvider.ts";
 import { ServerCorsProvider } from "../providers/ServerCorsProvider.ts";
 
 /**
  * Declares CORS configuration for specific server routes.
- * This descriptor provides path-based CORS configuration.
+ * This primitive provides path-based CORS configuration.
  *
  * @example
  * ```ts
@@ -18,15 +18,13 @@ import { ServerCorsProvider } from "../providers/ServerCorsProvider.ts";
  * }
  * ```
  */
-export const $cors = (
-  options: CorsDescriptorConfig,
-): AbstractCorsDescriptor => {
-  return createDescriptor(CorsDescriptor, options);
+export const $cors = (options: CorsPrimitiveConfig): AbstractCorsPrimitive => {
+  return createPrimitive(CorsPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface CorsDescriptorConfig extends Partial<CorsOptions> {
+export interface CorsPrimitiveConfig extends Partial<CorsOptions> {
   /** Name identifier for this CORS config (default: property key) */
   name?: string;
   /** Path patterns to match (supports wildcards like /api/*) */
@@ -35,14 +33,14 @@ export interface CorsDescriptorConfig extends Partial<CorsOptions> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface AbstractCorsDescriptor {
+export interface AbstractCorsPrimitive {
   readonly name: string;
-  readonly options: CorsDescriptorConfig;
+  readonly options: CorsPrimitiveConfig;
 }
 
-export class CorsDescriptor
-  extends Descriptor<CorsDescriptorConfig>
-  implements AbstractCorsDescriptor
+export class CorsPrimitive
+  extends Primitive<CorsPrimitiveConfig>
+  implements AbstractCorsPrimitive
 {
   protected readonly serverCorsProvider = $inject(ServerCorsProvider);
 
@@ -56,4 +54,4 @@ export class CorsDescriptor
   }
 }
 
-$cors[KIND] = CorsDescriptor;
+$cors[KIND] = CorsPrimitive;

package/src/server-cors/providers/ServerCorsProvider.ts

@@ -1,7 +1,7 @@
 import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { ServerRouterProvider } from "alepha/server";
-import type { CorsDescriptorConfig } from "../descriptors/$cors.ts";
+import type { CorsPrimitiveConfig } from "../primitives/$cors.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -64,12 +64,12 @@ export class ServerCorsProvider {
   /**
    * Registered CORS configurations with their path patterns
    */
-  public readonly registeredConfigs: CorsDescriptorConfig[] = [];
+  public readonly registeredConfigs: CorsPrimitiveConfig[] = [];
 
   /**
-   * Register a CORS configuration (called by descriptors)
+   * Register a CORS configuration (called by primitives)
    */
-  public registerCors(config: CorsDescriptorConfig): void {
+  public registerCors(config: CorsPrimitiveConfig): void {
     this.registeredConfigs.push(config);
   }
 
@@ -132,7 +132,7 @@ export class ServerCorsProvider {
   /**
    * Build complete CORS options by merging with global defaults
    */
-  protected buildCorsOptions(config: CorsDescriptorConfig): CorsOptions {
+  protected buildCorsOptions(config: CorsPrimitiveConfig): CorsOptions {
     return {
       origin: config.origin ?? this.globalOptions.origin,
       methods: config.methods ?? this.globalOptions.methods,

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

@@ -1,12 +1,12 @@
 import { $module } from "alepha";
-import { $client } from "./descriptors/$client.ts";
-import { $remote } from "./descriptors/$remote.ts";
+import { $client } from "./primitives/$client.ts";
+import { $remote } from "./primitives/$remote.ts";
 import { LinkProvider } from "./providers/LinkProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$client.ts";
-export * from "./descriptors/$remote.ts";
+export * from "./primitives/$client.ts";
+export * from "./primitives/$remote.ts";
 export * from "./providers/LinkProvider.ts";
 export * from "./schemas/apiLinksResponseSchema.ts";
 
@@ -14,6 +14,6 @@ export * from "./schemas/apiLinksResponseSchema.ts";
 
 export const AlephaServerLinks = $module({
   name: "alepha.server.links",
-  descriptors: [$remote, $client],
+  primitives: [$remote, $client],
   services: [LinkProvider],
 });

package/src/server-links/index.ts

@@ -1,19 +1,19 @@
 import "alepha/server/security";
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $client } from "./descriptors/$client.ts";
-import { $remote } from "./descriptors/$remote.ts";
+import { $client } from "./primitives/$client.ts";
+import { $remote } from "./primitives/$remote.ts";
 import { LinkProvider } from "./providers/LinkProvider.ts";
-import { RemoteDescriptorProvider } from "./providers/RemoteDescriptorProvider.ts";
+import { RemotePrimitiveProvider } from "./providers/RemotePrimitiveProvider.ts";
 import { ServerLinksProvider } from "./providers/ServerLinksProvider.ts";
 import type { ApiLinksResponse } from "./schemas/apiLinksResponseSchema.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$client.ts";
-export * from "./descriptors/$remote.ts";
+export * from "./primitives/$client.ts";
+export * from "./primitives/$remote.ts";
 export * from "./providers/LinkProvider.ts";
-export * from "./providers/RemoteDescriptorProvider.ts";
+export * from "./providers/RemotePrimitiveProvider.ts";
 export * from "./providers/ServerLinksProvider.ts";
 export * from "./schemas/apiLinksResponseSchema.ts";
 
@@ -36,7 +36,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -46,11 +46,11 @@ declare module "alepha" {
  */
 export const AlephaServerLinks = $module({
   name: "alepha.server.links",
-  descriptors: [$remote, $client],
+  primitives: [$remote, $client],
   services: [
     AlephaServer,
     ServerLinksProvider,
-    RemoteDescriptorProvider,
+    RemotePrimitiveProvider,
     LinkProvider,
   ],
 });

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

@@ -1,9 +1,9 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
-import type { ServiceAccountDescriptor } from "alepha/security";
-import type { ProxyDescriptorOptions } from "alepha/server/proxy";
+import { createPrimitive, KIND, Primitive } from "alepha";
+import type { ServiceAccountPrimitive } from "alepha/security";
+import type { ProxyPrimitiveOptions } from "alepha/server/proxy";
 
 /**
- * $remote is a descriptor that allows you to define remote service access.
+ * $remote is a primitive that allows you to define remote service access.
  *
  * Use it only when you have 2 or more services that need to communicate with each other.
  *
@@ -11,11 +11,11 @@ import type { ProxyDescriptorOptions } from "alepha/server/proxy";
  *
  * You can add a service account if you want to use a security layer.
  */
-export const $remote = (options: RemoteDescriptorOptions) => {
-  return createDescriptor(RemoteDescriptor, options);
+export const $remote = (options: RemotePrimitiveOptions) => {
+  return createPrimitive(RemotePrimitive, options);
 };
 
-export interface RemoteDescriptorOptions {
+export interface RemotePrimitiveOptions {
   /**
    * The URL of the remote service.
    * You can use a function to generate the URL dynamically.
@@ -52,7 +52,7 @@ export interface RemoteDescriptorOptions {
   proxy?:
     | boolean
     | Partial<
-        ProxyDescriptorOptions & {
+        ProxyPrimitiveOptions & {
           /**
            * If true, the remote service won't be available internally, only through the proxy.
            */
@@ -64,13 +64,13 @@ export interface RemoteDescriptorOptions {
    * For communication between the server and the remote service with a security layer.
    * This will be used for internal communication and will not be exposed to the client.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
 }
 
-export class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
+export class RemotePrimitive extends Primitive<RemotePrimitiveOptions> {
   public get name(): string {
     return this.options.name ?? this.config.propertyKey;
   }
 }
 
-$remote[KIND] = RemoteDescriptor;
+$remote[KIND] = RemotePrimitive;

package/src/server-links/providers/LinkProvider.ts

@@ -1,7 +1,7 @@
 import { $inject, Alepha, AlephaError, type Async, t } from "alepha";
 import { $logger } from "alepha/logger";
 import {
-  type ActionDescriptor,
+  type ActionPrimitive,
   type ClientRequestEntry,
   type ClientRequestOptions,
   type ClientRequestResponse,
@@ -79,7 +79,7 @@ export class LinkProvider {
 
   public get links(): HttpClientLink[] {
     // TODO: not performant at all, use a map instead for ServerLinks
-    const apiLinks = this.alepha.state.get(
+    const apiLinks = this.alepha.store.get(
       "alepha.server.request.apiLinks",
     )?.links;
     if (apiLinks) {
@@ -114,7 +114,7 @@ export class LinkProvider {
       },
     );
 
-    this.alepha.state.set("alepha.server.request.apiLinks", data);
+    this.alepha.store.set("alepha.server.request.apiLinks", data);
 
     return data.links;
   }
@@ -277,7 +277,7 @@ export class LinkProvider {
   ): Promise<HttpClientLink> {
     if (
       this.alepha.isBrowser() &&
-      !this.alepha.state.get("alepha.server.request.apiLinks")
+      !this.alepha.store.get("alepha.server.request.apiLinks")
     ) {
       await this.fetchLinks();
     }
@@ -334,15 +334,15 @@ export interface ClientScope {
 }
 
 export type HttpVirtualClient<T> = {
-  [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema>
+  [K in keyof T as T[K] extends ActionPrimitive<RequestConfigSchema>
     ? K
-    : never]: T[K] extends ActionDescriptor<infer Schema>
+    : never]: T[K] extends ActionPrimitive<infer Schema>
     ? VirtualAction<Schema>
     : never;
 };
 
 export interface VirtualAction<T extends RequestConfigSchema>
-  extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
+  extends Pick<ActionPrimitive<T>, "name" | "run" | "fetch"> {
   (
     config?: ClientRequestEntry<T>,
     opts?: ClientRequestOptions,

package/src/server-links/providers/{RemoteDescriptorProvider.ts → RemotePrimitiveProvider.ts}

@@ -1,9 +1,9 @@
 import { $env, $hook, $inject, Alepha, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { $retry } from "alepha/retry";
-import type { ServiceAccountDescriptor } from "alepha/security";
+import type { ServiceAccountPrimitive } from "alepha/security";
 import { ServerProxyProvider } from "alepha/server/proxy";
-import { $remote, type RemoteDescriptor } from "../descriptors/$remote.ts";
+import { $remote, type RemotePrimitive } from "../primitives/$remote.ts";
 import {
   type ApiLinksResponse,
   apiLinksResponseSchema,
@@ -17,7 +17,7 @@ const envSchema = t.object({
   }),
 });
 
-export class RemoteDescriptorProvider {
+export class RemotePrimitiveProvider {
   protected readonly env = $env(envSchema);
   protected readonly alepha = $inject(Alepha);
   protected readonly proxyProvider = $inject(ServerProxyProvider);
@@ -32,7 +32,7 @@ export class RemoteDescriptorProvider {
   public readonly configure = $hook({
     on: "configure",
     handler: async () => {
-      const remotes = this.alepha.descriptors($remote);
+      const remotes = this.alepha.primitives($remote);
       for (const remote of remotes) {
         await this.registerRemote(remote);
       }
@@ -78,7 +78,7 @@ export class RemoteDescriptorProvider {
     },
   });
 
-  public async registerRemote(value: RemoteDescriptor): Promise<void> {
+  public async registerRemote(value: RemotePrimitive): Promise<void> {
     const options = value.options;
     const url = typeof options.url === "string" ? options.url : options.url();
     const linkPath = LinkProvider.path.apiLinks;
@@ -225,7 +225,7 @@ export interface ServerRemote {
   /**
    * Force a default access token provider when not provided.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
 
   /**
    * Prefix for the remote service links.

package/src/server-links/providers/ServerLinksProvider.ts

@@ -18,7 +18,7 @@ import {
   apiLinksResponseSchema,
 } from "../schemas/apiLinksResponseSchema.ts";
 import { LinkProvider } from "./LinkProvider.ts";
-import { RemoteDescriptorProvider } from "./RemoteDescriptorProvider.ts";
+import { RemotePrimitiveProvider } from "./RemotePrimitiveProvider.ts";
 
 const envSchema = t.object({
   SERVER_API_PREFIX: t.text({
@@ -31,7 +31,7 @@ export class ServerLinksProvider {
   protected readonly env = $env(envSchema);
   protected readonly alepha = $inject(Alepha);
   protected readonly linkProvider = $inject(LinkProvider);
-  protected readonly remoteProvider = $inject(RemoteDescriptorProvider);
+  protected readonly remoteProvider = $inject(RemotePrimitiveProvider);
   protected readonly serverTimingProvider = $inject(ServerTimingProvider);
 
   public get prefix() {
@@ -42,7 +42,7 @@ export class ServerLinksProvider {
     on: "configure",
     handler: () => {
       // convert all $action to local links
-      for (const action of this.alepha.descriptors($action)) {
+      for (const action of this.alepha.primitives($action)) {
         this.linkProvider.registerLink({
           name: action.name,
           group: action.group,

package/src/server-proxy/index.ts

@@ -1,11 +1,11 @@
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $proxy } from "./descriptors/$proxy.ts";
+import { $proxy } from "./primitives/$proxy.ts";
 import { ServerProxyProvider } from "./providers/ServerProxyProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$proxy.ts";
+export * from "./primitives/$proxy.ts";
 export * from "./providers/ServerProxyProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -18,6 +18,6 @@ export * from "./providers/ServerProxyProvider.ts";
  */
 export const AlephaServerProxy = $module({
   name: "alepha.server.proxy",
-  descriptors: [$proxy],
+  primitives: [$proxy],
   services: [AlephaServer, ServerProxyProvider],
 });

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

@@ -1,10 +1,10 @@
-import { type Async, createDescriptor, Descriptor, KIND } from "alepha";
+import { type Async, createPrimitive, KIND, Primitive } from "alepha";
 import type { ServerRequest } from "alepha/server";
 
 /**
- * Creates a proxy descriptor to forward requests to another server.
+ * Creates a proxy primitive to forward requests to another server.
  *
- * This descriptor enables you to create reverse proxy functionality, allowing your Alepha server
+ * This primitive enables you to create reverse proxy functionality, allowing your Alepha server
  * to forward requests to other services while maintaining a unified API surface. It's particularly
  * useful for microservice architectures, API gateways, or when you need to aggregate multiple
  * services behind a single endpoint.
@@ -84,11 +84,11 @@ import type { ServerRequest } from "alepha/server";
  * }
  * ```
  */
-export const $proxy = (options: ProxyDescriptorOptions): ProxyDescriptor => {
-  return createDescriptor(ProxyDescriptor, options);
+export const $proxy = (options: ProxyPrimitiveOptions): ProxyPrimitive => {
+  return createPrimitive(ProxyPrimitive, options);
 };
 
-export type ProxyDescriptorOptions = {
+export type ProxyPrimitiveOptions = {
   /**
    * Path pattern to match for proxying requests.
    *
@@ -219,6 +219,6 @@ export type ProxyDescriptorOptions = {
   // retry?: RetryOptions;
 };
 
-export class ProxyDescriptor extends Descriptor<ProxyDescriptorOptions> {}
+export class ProxyPrimitive extends Primitive<ProxyPrimitiveOptions> {}
 
-$proxy[KIND] = ProxyDescriptor;
+$proxy[KIND] = ProxyPrimitive;

package/src/server-proxy/providers/ServerProxyProvider.ts

@@ -7,7 +7,7 @@ import {
   type ServerRequest,
   ServerRouterProvider,
 } from "alepha/server";
-import { $proxy, type ProxyDescriptorOptions } from "../descriptors/$proxy.ts";
+import { $proxy, type ProxyPrimitiveOptions } from "../primitives/$proxy.ts";
 
 export class ServerProxyProvider {
   protected readonly log = $logger();
@@ -17,13 +17,13 @@ export class ServerProxyProvider {
   protected readonly configure = $hook({
     on: "configure",
     handler: () => {
-      for (const proxy of this.alepha.descriptors($proxy)) {
+      for (const proxy of this.alepha.primitives($proxy)) {
         this.createProxy(proxy.options);
       }
     },
   });
 
-  public createProxy(options: ProxyDescriptorOptions): void {
+  public createProxy(options: ProxyPrimitiveOptions): void {
     if (options.disabled) {
       return;
     }
@@ -52,7 +52,7 @@ export class ServerProxyProvider {
 
   public createProxyHandler(
     target: string,
-    options: Omit<ProxyDescriptorOptions, "path">,
+    options: Omit<ProxyPrimitiveOptions, "path">,
   ): ServerHandler {
     return async (request) => {
       const url = new URL(target + request.url.pathname);

package/src/server-rate-limit/index.ts

@@ -1,17 +1,17 @@
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $rateLimit } from "./descriptors/$rateLimit.ts";
+import { $rateLimit } from "./primitives/$rateLimit.ts";
 import { ServerRateLimitProvider } from "./providers/ServerRateLimitProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$rateLimit.ts";
+export * from "./primitives/$rateLimit.ts";
 export * from "./providers/ServerRateLimitProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 declare module "alepha/server" {
-  interface ActionDescriptorOptions<TConfig> {
+  interface ActionPrimitiveOptions<TConfig> {
     /**
      * Rate limiting configuration for this action.
      * When specified, the action will be rate limited according to these settings.
@@ -47,8 +47,8 @@ export interface RateLimitOptions {
  * Provides rate limiting capabilities for server routes and actions with configurable limits and windows.
  *
  * The server-rate-limit module enables per-route and per-action rate limiting using either:
- * - The `$rateLimit` descriptor with `paths` option for path-based rate limiting
- * - The `rateLimit` option in action descriptors for action-specific limiting
+ * - The `$rateLimit` primitive with `paths` option for path-based rate limiting
+ * - The `rateLimit` option in action primitives for action-specific limiting
  *
  * It offers sliding window rate limiting, custom key generation, and seamless integration with server routes.
  *
@@ -71,6 +71,6 @@ export interface RateLimitOptions {
  */
 export const AlephaServerRateLimit = $module({
   name: "alepha.server.rate-limit",
-  descriptors: [$rateLimit],
+  primitives: [$rateLimit],
   services: [AlephaServer, ServerRateLimitProvider],
 });