alepha 0.13.1 → 0.13.3

package/src/server-rate-limit/{descriptors → primitives}/$rateLimit.ts

@@ -1,4 +1,4 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type { ServerRequest } from "alepha/server";
 import type { RateLimitOptions } from "../index.ts";
 import {
@@ -8,7 +8,7 @@ import {
 
 /**
  * Declares rate limiting for server routes or custom usage.
- * This descriptor provides methods to check rate limits and configure behavior
+ * This primitive provides methods to check rate limits and configure behavior
  * within the server request/response cycle.
  *
  * @example
@@ -33,32 +33,32 @@ import {
  * ```
  */
 export const $rateLimit = (
-  options: RateLimitDescriptorOptions = {},
-): AbstractRateLimitDescriptor => {
-  return createDescriptor(RateLimitDescriptor, options);
+  options: RateLimitPrimitiveOptions = {},
+): AbstractRateLimitPrimitive => {
+  return createPrimitive(RateLimitPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface RateLimitDescriptorOptions extends RateLimitOptions {
+export interface RateLimitPrimitiveOptions extends RateLimitOptions {
   /** Name identifier for this rate limit (default: property key) */
   name?: string;
   /** Path patterns to match (supports wildcards like /api/*) */
   paths?: string[];
 }
 
-export interface AbstractRateLimitDescriptor {
+export interface AbstractRateLimitPrimitive {
   readonly name: string;
-  readonly options: RateLimitDescriptorOptions;
+  readonly options: RateLimitPrimitiveOptions;
   check(
     request: ServerRequest,
     options?: RateLimitOptions,
   ): Promise<RateLimitResult>;
 }
 
-export class RateLimitDescriptor
-  extends Descriptor<RateLimitDescriptorOptions>
-  implements AbstractRateLimitDescriptor
+export class RateLimitPrimitive
+  extends Primitive<RateLimitPrimitiveOptions>
+  implements AbstractRateLimitPrimitive
 {
   protected readonly serverRateLimitProvider = $inject(ServerRateLimitProvider);
 
@@ -72,7 +72,7 @@ export class RateLimitDescriptor
   }
 
   /**
-   * Checks rate limit for the given request using this descriptor's configuration.
+   * Checks rate limit for the given request using this primitive's configuration.
    */
   public async check(
     request: ServerRequest,
@@ -83,4 +83,4 @@ export class RateLimitDescriptor
   }
 }
 
-$rateLimit[KIND] = RateLimitDescriptor;
+$rateLimit[KIND] = RateLimitPrimitive;

package/src/server-rate-limit/providers/ServerRateLimitProvider.ts

@@ -6,8 +6,8 @@ import {
   type ServerRequest,
   ServerRouterProvider,
 } from "alepha/server";
-import type { RateLimitDescriptorOptions } from "../descriptors/$rateLimit.ts";
 import type { RateLimitOptions } from "../index.ts";
+import type { RateLimitPrimitiveOptions } from "../primitives/$rateLimit.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -85,12 +85,12 @@ export class ServerRateLimitProvider {
   /**
    * Registered rate limit configurations with their path patterns
    */
-  public readonly registeredConfigs: RateLimitDescriptorOptions[] = [];
+  public readonly registeredConfigs: RateLimitPrimitiveOptions[] = [];
 
   /**
-   * Register a rate limit configuration (called by descriptors)
+   * Register a rate limit configuration (called by primitives)
    */
-  public registerRateLimit(config: RateLimitDescriptorOptions): void {
+  public registerRateLimit(config: RateLimitPrimitiveOptions): void {
     this.registeredConfigs.push(config);
   }
 
@@ -168,7 +168,7 @@ export class ServerRateLimitProvider {
    * Build complete rate limit options by merging with global defaults
    */
   protected buildRateLimitOptions(
-    config: RateLimitDescriptorOptions,
+    config: RateLimitPrimitiveOptions,
   ): RateLimitOptions {
     return {
       max: config.max ?? this.globalOptions.max,

package/src/server-security/index.ts

@@ -8,7 +8,7 @@ import {
   type UserAccountToken,
 } from "alepha/security";
 import { AlephaServer, type FetchOptions } from "alepha/server";
-import { $basicAuth } from "./descriptors/$basicAuth.ts";
+import { $basicAuth } from "./primitives/$basicAuth.ts";
 import { ServerBasicAuthProvider } from "./providers/ServerBasicAuthProvider.ts";
 import {
   type ServerRouteSecure,
@@ -17,7 +17,7 @@ import {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$basicAuth.ts";
+export * from "./primitives/$basicAuth.ts";
 export * from "./providers/ServerBasicAuthProvider.ts";
 export * from "./providers/ServerSecurityProvider.ts";
 
@@ -84,7 +84,7 @@ declare module "alepha/server" {
  */
 export const AlephaServerSecurity = $module({
   name: "alepha.server.security",
-  descriptors: [$realm, $role, $permission, $basicAuth],
+  primitives: [$realm, $role, $permission, $basicAuth],
   services: [
     AlephaServer,
     AlephaSecurity,

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

@@ -1,32 +1,32 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type { ServerRequest } from "alepha/server";
 import type {
-  BasicAuthDescriptorConfig,
   BasicAuthOptions,
+  BasicAuthPrimitiveConfig,
 } from "../providers/ServerBasicAuthProvider.ts";
 import { ServerBasicAuthProvider } from "../providers/ServerBasicAuthProvider.ts";
 
 /**
  * Declares HTTP Basic Authentication for server routes.
- * This descriptor provides methods to protect routes with username/password authentication.
+ * This primitive provides methods to protect routes with username/password authentication.
  */
 export const $basicAuth = (
-  options: BasicAuthDescriptorConfig,
-): AbstractBasicAuthDescriptor => {
-  return createDescriptor(BasicAuthDescriptor, options);
+  options: BasicAuthPrimitiveConfig,
+): AbstractBasicAuthPrimitive => {
+  return createPrimitive(BasicAuthPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface AbstractBasicAuthDescriptor {
+export interface AbstractBasicAuthPrimitive {
   readonly name: string;
-  readonly options: BasicAuthDescriptorConfig;
+  readonly options: BasicAuthPrimitiveConfig;
   check(request: ServerRequest, options?: BasicAuthOptions): void;
 }
 
-export class BasicAuthDescriptor
-  extends Descriptor<BasicAuthDescriptorConfig>
-  implements AbstractBasicAuthDescriptor
+export class BasicAuthPrimitive
+  extends Primitive<BasicAuthPrimitiveConfig>
+  implements AbstractBasicAuthPrimitive
 {
   protected readonly serverBasicAuthProvider = $inject(ServerBasicAuthProvider);
 
@@ -40,7 +40,7 @@ export class BasicAuthDescriptor
   }
 
   /**
-   * Checks basic auth for the given request using this descriptor's configuration.
+   * Checks basic auth for the given request using this primitive's configuration.
    */
   public check(request: ServerRequest, options?: BasicAuthOptions): void {
     const mergedOptions = { ...this.options, ...options };
@@ -48,4 +48,4 @@ export class BasicAuthDescriptor
   }
 }
 
-$basicAuth[KIND] = BasicAuthDescriptor;
+$basicAuth[KIND] = BasicAuthPrimitive;

package/src/server-security/providers/ServerBasicAuthProvider.ts

@@ -14,7 +14,7 @@ export interface BasicAuthOptions {
   password: string;
 }
 
-export interface BasicAuthDescriptorConfig extends BasicAuthOptions {
+export interface BasicAuthPrimitiveConfig extends BasicAuthOptions {
   /** Name identifier for this basic auth (default: property key) */
   name?: string;
   /** Path patterns to match (supports wildcards like /devtools/*) */
@@ -30,14 +30,14 @@ export class ServerBasicAuthProvider {
   protected readonly realm = "Secure Area";
 
   /**
-   * Registered basic auth descriptors with their configurations
+   * Registered basic auth primitives with their configurations
    */
-  public readonly registeredAuths: BasicAuthDescriptorConfig[] = [];
+  public readonly registeredAuths: BasicAuthPrimitiveConfig[] = [];
 
   /**
-   * Register a basic auth configuration (called by descriptors)
+   * Register a basic auth configuration (called by primitives)
    */
-  public registerAuth(config: BasicAuthDescriptorConfig): void {
+  public registerAuth(config: BasicAuthPrimitiveConfig): void {
     this.registeredAuths.push(config);
   }
 

package/src/server-security/providers/ServerSecurityProvider.ts

@@ -28,7 +28,7 @@ export class ServerSecurityProvider {
   protected readonly onConfigure = $hook({
     on: "configure",
     handler: async () => {
-      for (const action of this.alepha.descriptors($action)) {
+      for (const action of this.alepha.primitives($action)) {
         // -------------------------------------------------------------------------------------------------------------
         // if the action is disabled or not secure, we do NOT create a permission for it
         // -------------------------------------------------------------------------------------------------------------
@@ -87,7 +87,7 @@ export class ServerSecurityProvider {
           this.check(request.user, route.secure);
         }
 
-        this.alepha.state.set(
+        this.alepha.store.set(
           "alepha.server.request.user",
           this.alepha.codec.decode(userAccountInfoSchema, request.user),
         );
@@ -139,7 +139,7 @@ export class ServerSecurityProvider {
           this.check(request.user, route.secure);
         }
 
-        this.alepha.state.set(
+        this.alepha.store.set(
           "alepha.server.request.user",
           // remove sensitive info
           this.alepha.codec.decode(userAccountInfoSchema, request.user),
@@ -198,7 +198,7 @@ export class ServerSecurityProvider {
     let user: UserAccountToken | undefined;
 
     const fromContext = this.alepha.context.get<ServerRequest>("request")?.user;
-    const fromSystem = this.alepha.state.get(
+    const fromSystem = this.alepha.store.get(
       "alepha.server.security.system.user",
     );
 

package/src/server-static/index.ts

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

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

@@ -1,16 +1,14 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
+import { createPrimitive, KIND, Primitive } from "alepha";
 import type { DurationLike } from "alepha/datetime";
 
 /**
  * Create a new static file handler.
  */
-export const $serve = (
-  options: ServeDescriptorOptions = {},
-): ServeDescriptor => {
-  return createDescriptor(ServeDescriptor, options);
+export const $serve = (options: ServePrimitiveOptions = {}): ServePrimitive => {
+  return createPrimitive(ServePrimitive, options);
 };
 
-export interface ServeDescriptorOptions {
+export interface ServePrimitiveOptions {
   /**
    * Prefix for the served path.
    *
@@ -26,7 +24,7 @@ export interface ServeDescriptorOptions {
   root?: string;
 
   /**
-   * If true, descriptor will be ignored.
+   * If true, primitive will be ignored.
    *
    * @default false
    */
@@ -53,7 +51,7 @@ export interface ServeDescriptorOptions {
   historyApiFallback?: boolean;
 
   /**
-   * Optional name of the descriptor.
+   * Optional name of the primitive.
    * This is used for logging and debugging purposes.
    *
    * @default Key name.
@@ -91,6 +89,6 @@ export interface CacheControlOptions {
   immutable: boolean;
 }
 
-export class ServeDescriptor extends Descriptor<ServeDescriptorOptions> {}
+export class ServePrimitive extends Primitive<ServePrimitiveOptions> {}
 
-$serve[KIND] = ServeDescriptor;
+$serve[KIND] = ServePrimitive;

package/src/server-static/providers/ServerStaticProvider.ts

@@ -7,7 +7,7 @@ import { DateTimeProvider } from "alepha/datetime";
 import { FileDetector } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { type ServerHandler, ServerRouterProvider } from "alepha/server";
-import { $serve, type ServeDescriptorOptions } from "../descriptors/$serve.ts";
+import { $serve, type ServePrimitiveOptions } from "../primitives/$serve.ts";
 
 export class ServerStaticProvider {
   protected readonly alepha = $inject(Alepha);
@@ -22,14 +22,14 @@ export class ServerStaticProvider {
     handler: async () => {
       await Promise.all(
         this.alepha
-          .descriptors($serve)
+          .primitives($serve)
           .map((it) => this.createStaticServer(it.options)),
       );
     },
   });
 
   public async createStaticServer(
-    options: ServeDescriptorOptions,
+    options: ServePrimitiveOptions,
   ): Promise<void> {
     const prefix = options.path ?? "/";
 
@@ -98,8 +98,15 @@ export class ServerStaticProvider {
           reply.headers["content-type"] = "text/html";
           reply.status = 200;
 
-          // Serve index.html for all unmatched routes
-          return createReadStream(join(root, "index.html"));
+          return new Promise<any>((resolve, reject) => {
+            const stream = createReadStream(join(root, "index.html"));
+            stream.on("open", () => {
+              resolve(stream);
+            });
+            stream.on("error", (err) => {
+              reject(err);
+            });
+          });
         },
       });
     }
@@ -107,7 +114,7 @@ export class ServerStaticProvider {
 
   public async createFileHandler(
     filepath: string,
-    options: ServeDescriptorOptions,
+    options: ServePrimitiveOptions,
   ): Promise<ServerHandler> {
     const filename = basename(filepath);
 
@@ -161,7 +168,15 @@ export class ServerStaticProvider {
         return;
       }
 
-      return createReadStream(path);
+      return new Promise<any>((resolve, reject) => {
+        const stream = createReadStream(path);
+        stream.on("open", () => {
+          resolve(stream);
+        });
+        stream.on("error", (err) => {
+          reject(err);
+        });
+      });
     };
   }
 
@@ -184,7 +199,7 @@ export class ServerStaticProvider {
 
   protected getCacheControl(
     filename: string,
-    options: ServeDescriptorOptions,
+    options: ServePrimitiveOptions,
   ): { maxAge: number; immutable: boolean } | undefined {
     if (!options.cacheControl) {
       return;
@@ -228,6 +243,6 @@ export class ServerStaticProvider {
 }
 
 export interface ServeDirectory {
-  options: ServeDescriptorOptions;
+  options: ServePrimitiveOptions;
   files: string[];
 }

package/src/server-swagger/index.ts

@@ -3,18 +3,18 @@ import { $module } from "alepha";
 import { AlephaServer, type RequestConfigSchema } from "alepha/server";
 import { AlephaServerCache } from "alepha/server/cache";
 import { AlephaServerStatic } from "alepha/server/static";
-import { $swagger } from "./descriptors/$swagger.ts";
+import { $swagger } from "./primitives/$swagger.ts";
 import { ServerSwaggerProvider } from "./providers/ServerSwaggerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$swagger.ts";
+export * from "./primitives/$swagger.ts";
 export * from "./providers/ServerSwaggerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 declare module "alepha/server" {
-  interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> {
+  interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> {
     /**
      * Short description of the route.
      */
@@ -39,13 +39,13 @@ declare module "alepha/server" {
  */
 export const AlephaServerSwagger = $module({
   name: "alepha.server.swagger",
-  descriptors: [$swagger],
+  primitives: [$swagger],
   services: [ServerSwaggerProvider],
   register: (alepha) => {
     alepha.with(AlephaServer);
     alepha.with(AlephaServerCache);
     alepha.with(AlephaServerStatic);
     alepha.with(ServerSwaggerProvider);
-    alepha.state.push("alepha.build.assets", "alepha");
+    alepha.store.push("alepha.build.assets", "alepha");
   },
 });

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

@@ -1,9 +1,9 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
+import { createPrimitive, KIND, Primitive } from "alepha";
 
 /**
- * Creates an OpenAPI/Swagger documentation descriptor with interactive UI.
+ * Creates an OpenAPI/Swagger documentation primitive with interactive UI.
  *
- * Automatically generates API documentation from your $action descriptors and serves
+ * Automatically generates API documentation from your $action primitives and serves
  * an interactive Swagger UI for testing endpoints. Supports customization, tag filtering,
  * and OAuth configuration.
  *
@@ -24,12 +24,12 @@ import { createDescriptor, Descriptor, KIND } from "alepha";
  * ```
  */
 export const $swagger = (
-  options: SwaggerDescriptorOptions = {},
-): SwaggerDescriptor => {
-  return createDescriptor(SwaggerDescriptor, options);
+  options: SwaggerPrimitiveOptions = {},
+): SwaggerPrimitive => {
+  return createPrimitive(SwaggerPrimitive, options);
 };
 
-export interface SwaggerDescriptorOptions {
+export interface SwaggerPrimitiveOptions {
   info?: OpenApiDocument["info"];
 
   /**
@@ -121,9 +121,9 @@ export interface SwaggerUiOptions {
   };
 }
 
-export class SwaggerDescriptor extends Descriptor<SwaggerDescriptorOptions> {}
+export class SwaggerPrimitive extends Primitive<SwaggerPrimitiveOptions> {}
 
-$swagger[KIND] = SwaggerDescriptor;
+$swagger[KIND] = SwaggerPrimitive;
 
 export interface OpenApiDocument {
   openapi: string;

package/src/server-swagger/providers/ServerSwaggerProvider.ts

@@ -17,7 +17,7 @@ import { $logger } from "alepha/logger";
 import { AlephaSecurity } from "alepha/security";
 import {
   $action,
-  type ActionDescriptor,
+  type ActionPrimitive,
   type RequestConfigSchema,
   ServerProvider,
   ServerRouterProvider,
@@ -27,8 +27,8 @@ import {
   $swagger,
   type OpenApiDocument,
   type OpenApiOperation,
-  type SwaggerDescriptorOptions,
-} from "../descriptors/$swagger.ts";
+  type SwaggerPrimitiveOptions,
+} from "../primitives/$swagger.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -74,7 +74,7 @@ export class ServerSwaggerProvider {
     on: "configure",
     priority: "last", // wait for all configurations, sometimes some actions are registered late!
     handler: async (alepha) => {
-      const options = alepha.descriptors($swagger)?.[0]?.options;
+      const options = alepha.primitives($swagger)?.[0]?.options;
       if (!options) {
         return;
       }
@@ -84,14 +84,14 @@ export class ServerSwaggerProvider {
   });
 
   public async createSwagger(
-    options: SwaggerDescriptorOptions,
+    options: SwaggerPrimitiveOptions,
   ): Promise<OpenApiDocument | undefined> {
     if (options.disabled) {
       return;
     }
 
     const json = this.configureOpenApi(
-      this.alepha.descriptors($action),
+      this.alepha.primitives($action),
       options,
     );
 
@@ -111,8 +111,8 @@ export class ServerSwaggerProvider {
   }
 
   protected configureOpenApi(
-    actions: ActionDescriptor<RequestConfigSchema>[],
-    doc: SwaggerDescriptorOptions,
+    actions: ActionPrimitive<RequestConfigSchema>[],
+    doc: SwaggerPrimitiveOptions,
   ): OpenApiDocument {
     const openApi: OpenApiDocument = {
       openapi: "3.0.0",
@@ -290,7 +290,7 @@ export class ServerSwaggerProvider {
     });
   }
 
-  public getResponseSchema(route: ActionDescriptor<RequestConfigSchema>):
+  public getResponseSchema(route: ActionPrimitive<RequestConfigSchema>):
     | {
         type?: string;
         schema?: any;
@@ -357,7 +357,7 @@ export class ServerSwaggerProvider {
 
   protected async configureSwaggerUi(
     prefix: string,
-    options: SwaggerDescriptorOptions,
+    options: SwaggerPrimitiveOptions,
   ): Promise<void> {
     const ui = typeof options.ui === "object" ? options.ui : {};
     const initializer = `
@@ -391,6 +391,7 @@ window.onload = function() {
     const root = await this.getAssetPath(
       ui.root,
       join(dirname, "../../assets/swagger-ui"),
+      join(dirname, "../../../assets/swagger-ui"),
       join(dirname, "../../../../assets/swagger-ui"),
     );
 

package/src/sms/index.ts

@@ -1,13 +1,13 @@
 import { $module } from "alepha";
-import { $sms } from "./descriptors/$sms.ts";
+import { $sms } from "./primitives/$sms.ts";
 import { LocalSmsProvider } from "./providers/LocalSmsProvider.ts";
 import { MemorySmsProvider } from "./providers/MemorySmsProvider.ts";
 import { SmsProvider } from "./providers/SmsProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$sms.ts";
 export * from "./errors/SmsError.ts";
+export * from "./primitives/$sms.ts";
 export * from "./providers/LocalSmsProvider.ts";
 export * from "./providers/MemorySmsProvider.ts";
 export * from "./providers/SmsProvider.ts";
@@ -36,7 +36,7 @@ declare module "alepha" {
 /**
  * Provides SMS sending capabilities for Alepha applications with multiple provider backends.
  *
- * The SMS module enables declarative SMS sending through the `$sms` descriptor, allowing you to send
+ * The SMS module enables declarative SMS sending through the `$sms` primitive, allowing you to send
  * text messages through different providers: memory (for testing) or local file system.
  * It supports automatic provider selection based on environment configuration.
  *
@@ -45,7 +45,7 @@ declare module "alepha" {
  */
 export const AlephaSms = $module({
   name: "alepha.sms",
-  descriptors: [$sms],
+  primitives: [$sms],
   services: [SmsProvider, MemorySmsProvider, LocalSmsProvider],
   register: (alepha) =>
     alepha.with({

package/src/sms/{descriptors → primitives}/$sms.ts

@@ -1,8 +1,8 @@
 import {
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   type InstantiableClass,
   KIND,
+  Primitive,
 } from "alepha";
 import { MemorySmsProvider } from "../providers/MemorySmsProvider.ts";
 import type { SmsSendOptions } from "../providers/SmsProvider.ts";
@@ -10,12 +10,12 @@ import { SmsProvider } from "../providers/SmsProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export const $sms = (options: SmsDescriptorOptions = {}) =>
-  createDescriptor(SmsDescriptor, options);
+export const $sms = (options: SmsPrimitiveOptions = {}) =>
+  createPrimitive(SmsPrimitive, options);
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface SmsDescriptorOptions {
+export interface SmsPrimitiveOptions {
   name?: string;
   provider?: InstantiableClass<SmsProvider> | "memory";
 }
@@ -23,7 +23,7 @@ export interface SmsDescriptorOptions {
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * SMS descriptor for sending SMS messages through various providers.
+ * SMS primitive for sending SMS messages through various providers.
  *
  * Usage:
  * ```typescript
@@ -39,7 +39,7 @@ export interface SmsDescriptorOptions {
  * }
  * ```
  */
-export class SmsDescriptor extends Descriptor<SmsDescriptorOptions> {
+export class SmsPrimitive extends Primitive<SmsPrimitiveOptions> {
   protected readonly provider = this.$provider();
 
   public get name() {
@@ -82,4 +82,4 @@ export class SmsDescriptor extends Descriptor<SmsDescriptorOptions> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-$sms[KIND] = SmsDescriptor;
+$sms[KIND] = SmsPrimitive;