alepha 0.13.0 → 0.13.2

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;

package/src/thread/index.ts

@@ -1,10 +1,10 @@
 import { $module, Alepha } from "alepha";
-import { $thread } from "./descriptors/$thread.ts";
+import { $thread } from "./primitives/$thread.ts";
 import { ThreadProvider } from "./providers/ThreadProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$thread.ts";
+export * from "./primitives/$thread.ts";
 export * from "./providers/ThreadProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -29,6 +29,6 @@ Alepha.prototype.isWorkerThread = function (this: Alepha): boolean {
  */
 export const AlephaThread = $module({
   name: "alepha.thread",
-  descriptors: [$thread],
+  primitives: [$thread],
   services: [ThreadProvider],
 });

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

@@ -1,12 +1,12 @@
 import { cpus } from "node:os";
 import { MessageChannel, type MessagePort, Worker } from "node:worker_threads";
 import type { TSchema } from "alepha";
-import { createDescriptor, Descriptor, KIND, TypeBoxValue } from "alepha";
+import { createPrimitive, KIND, Primitive, TypeBoxValue } from "alepha";
 
 /**
- * Creates a worker thread descriptor for offloading CPU-intensive tasks to separate threads.
+ * Creates a worker thread primitive for offloading CPU-intensive tasks to separate threads.
  *
- * This descriptor enables you to run JavaScript code in Node.js worker threads, allowing you to
+ * This primitive enables you to run JavaScript code in Node.js worker threads, allowing you to
  * leverage multiple CPU cores and avoid blocking the main event loop. It provides a pool-based
  * approach with intelligent thread reuse and automatic lifecycle management.
  *
@@ -117,13 +117,13 @@ import { createDescriptor, Descriptor, KIND, TypeBoxValue } from "alepha";
  * }
  * ```
  */
-export const $thread = (options: ThreadDescriptorOptions): ThreadDescriptor => {
-  return createDescriptor(ThreadDescriptor, options);
+export const $thread = (options: ThreadPrimitiveOptions): ThreadPrimitive => {
+  return createPrimitive(ThreadPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface ThreadDescriptorOptions {
+export interface ThreadPrimitiveOptions {
   /**
    * Unique name for this thread worker.
    *
@@ -132,7 +132,7 @@ export interface ThreadDescriptorOptions {
    * - Logging and debugging
    * - Error messages and stack traces
    *
-   * If not provided, defaults to the property key of the descriptor.
+   * If not provided, defaults to the property key of the primitive.
    *
    * @example "image-processor"
    * @example "crypto-worker"
@@ -210,7 +210,7 @@ export interface ThreadDescriptorOptions {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class ThreadDescriptor extends Descriptor<ThreadDescriptorOptions> {
+export class ThreadPrimitive extends Primitive<ThreadPrimitiveOptions> {
   protected readonly script = process.argv[1];
   static readonly globalPool = new Map<string, ThreadPool>();
 
@@ -227,8 +227,8 @@ export class ThreadDescriptor extends Descriptor<ThreadDescriptorOptions> {
   }
 
   private getPool(): ThreadPool {
-    if (!ThreadDescriptor.globalPool.has(this.name)) {
-      ThreadDescriptor.globalPool.set(
+    if (!ThreadPrimitive.globalPool.has(this.name)) {
+      ThreadPrimitive.globalPool.set(
         this.name,
         new ThreadPool(
           this.name,
@@ -238,7 +238,7 @@ export class ThreadDescriptor extends Descriptor<ThreadDescriptorOptions> {
         ),
       );
     }
-    return ThreadDescriptor.globalPool.get(this.name)!;
+    return ThreadPrimitive.globalPool.get(this.name)!;
   }
 
   public async execute<T = any>(data?: any, schema?: TSchema): Promise<T> {
@@ -264,11 +264,11 @@ export class ThreadDescriptor extends Descriptor<ThreadDescriptorOptions> {
   public async terminate(): Promise<void> {
     const pool = this.getPool();
     await pool.terminate();
-    ThreadDescriptor.globalPool.delete(this.name);
+    ThreadPrimitive.globalPool.delete(this.name);
   }
 }
 
-$thread[KIND] = ThreadDescriptor;
+$thread[KIND] = ThreadPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/thread/providers/ThreadProvider.ts

@@ -1,7 +1,7 @@
 import { parentPort, workerData } from "node:worker_threads";
 import { $env, $hook, t } from "alepha";
 import { $logger } from "alepha/logger";
-import { $thread } from "../descriptors/$thread.ts";
+import { $thread } from "../primitives/$thread.ts";
 
 interface ThreadMessage<T = any> {
   id: string;
@@ -26,15 +26,15 @@ export class ThreadProvider {
         return;
       }
 
-      const threads = alepha.descriptors($thread);
-      const threadDescriptor = threads.find((thread) => thread.name === worker);
+      const threads = alepha.primitives($thread);
+      const threadPrimitive = threads.find((thread) => thread.name === worker);
 
-      if (!threadDescriptor) {
+      if (!threadPrimitive) {
         this.log.error(`Thread not found: ${worker}`);
         return;
       }
 
-      this.log.info(`Thread ready: ${threadDescriptor.name}`);
+      this.log.info(`Thread ready: ${threadPrimitive.name}`);
 
       // Use the message channel port from worker data if available, fallback to parentPort
       const communicationPort = workerData?.port || parentPort;
@@ -48,10 +48,8 @@ export class ThreadProvider {
       communicationPort.on("message", async (message: ThreadMessage) => {
         if (message.type === "execute") {
           try {
-            this.log.debug(
-              `Executing thread handler: ${threadDescriptor.name}`,
-            );
-            const result = await threadDescriptor.options.handler();
+            this.log.debug(`Executing thread handler: ${threadPrimitive.name}`);
+            const result = await threadPrimitive.options.handler();
 
             communicationPort.postMessage({
               id: message.id,

package/src/topic/index.ts

@@ -1,14 +1,14 @@
 import { $module, type Alepha } from "alepha";
-import { $subscriber } from "./descriptors/$subscriber.ts";
-import { $topic } from "./descriptors/$topic.ts";
+import { $subscriber } from "./primitives/$subscriber.ts";
+import { $topic } from "./primitives/$topic.ts";
 import { MemoryTopicProvider } from "./providers/MemoryTopicProvider.ts";
 import { TopicProvider } from "./providers/TopicProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$subscriber.ts";
-export * from "./descriptors/$topic.ts";
 export * from "./errors/TopicTimeoutError.ts";
+export * from "./primitives/$subscriber.ts";
+export * from "./primitives/$topic.ts";
 export * from "./providers/MemoryTopicProvider.ts";
 export * from "./providers/TopicProvider.ts";
 
@@ -25,7 +25,7 @@ export * from "./providers/TopicProvider.ts";
  */
 export const AlephaTopic = $module({
   name: "alepha.topic",
-  descriptors: [$topic, $subscriber],
+  primitives: [$topic, $subscriber],
   services: [TopicProvider, MemoryTopicProvider],
   register: (alepha: Alepha) =>
     alepha.with({

package/src/topic/{descriptors → primitives}/$subscriber.ts

@@ -1,19 +1,19 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
+import { createPrimitive, KIND, Primitive } from "alepha";
 import type {
-  TopicDescriptor,
   TopicHandler,
   TopicMessageSchema,
+  TopicPrimitive,
 } from "./$topic.ts";
 
 /**
- * Creates a subscriber descriptor to listen for messages from a specific topic.
+ * Creates a subscriber primitive to listen for messages from a specific topic.
  *
  * Provides a dedicated message subscriber that connects to a topic and processes messages
  * with custom handler logic, enabling scalable pub/sub architectures where multiple
  * subscribers can react to the same events independently.
  *
  * **Key Features**
- * - Seamless integration with any $topic descriptor
+ * - Seamless integration with any $topic primitive
  * - Full type safety inherited from topic schema
  * - Real-time message delivery when events are published
  * - Error isolation between subscribers
@@ -61,16 +61,16 @@ import type {
  * ```
  */
 export const $subscriber = <T extends TopicMessageSchema>(
-  options: SubscriberDescriptorOptions<T>,
-): SubscriberDescriptor<T> => {
-  return createDescriptor(SubscriberDescriptor<T>, options);
+  options: SubscriberPrimitiveOptions<T>,
+): SubscriberPrimitive<T> => {
+  return createPrimitive(SubscriberPrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
+export interface SubscriberPrimitiveOptions<T extends TopicMessageSchema> {
   /**
-   * The topic descriptor that this subscriber will listen to for messages.
+   * The topic primitive that this subscriber will listen to for messages.
    *
    * This establishes the connection between the subscriber and its source topic:
    * - The subscriber inherits the topic's message schema for type safety
@@ -97,12 +97,12 @@ export interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
    *
    * // Then, create a subscriber for that topic
    * activitySubscriber = $subscriber({
-   *   topic: this.userEvents,  // Reference the topic descriptor
+   *   topic: this.userEvents,  // Reference the topic primitive
    *   handler: async (message) => { } // Process messages here
    * });
    * ```
    */
-  topic: TopicDescriptor<T>;
+  topic: TopicPrimitive<T>;
 
   /**
    * Message handler function that processes individual messages from the topic.
@@ -203,8 +203,8 @@ export interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class SubscriberDescriptor<
+export class SubscriberPrimitive<
   T extends TopicMessageSchema,
-> extends Descriptor<SubscriberDescriptorOptions<T>> {}
+> extends Primitive<SubscriberPrimitiveOptions<T>> {}
 
-$subscriber[KIND] = SubscriberDescriptor;
+$subscriber[KIND] = SubscriberPrimitive;

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

@@ -1,8 +1,8 @@
 import {
   $inject,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Service,
   type Static,
   type TSchema,
@@ -21,7 +21,7 @@ import {
 } from "../providers/TopicProvider.ts";
 
 /**
- * Creates a topic descriptor for publish/subscribe messaging and event-driven architecture.
+ * Creates a topic primitive for publish/subscribe messaging and event-driven architecture.
  *
  * Enables decoupled communication through a pub/sub pattern where publishers send messages
  * and multiple subscribers receive them. Supports type-safe messages, real-time delivery,
@@ -59,14 +59,14 @@ import {
  * ```
  */
 export const $topic = <T extends TopicMessageSchema>(
-  options: TopicDescriptorOptions<T>,
-): TopicDescriptor<T> => {
-  return createDescriptor(TopicDescriptor<T>, options);
+  options: TopicPrimitiveOptions<T>,
+): TopicPrimitive<T> => {
+  return createPrimitive(TopicPrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface TopicDescriptorOptions<T extends TopicMessageSchema> {
+export interface TopicPrimitiveOptions<T extends TopicMessageSchema> {
   /**
    * Unique name identifier for the topic.
    *
@@ -248,8 +248,8 @@ export interface TopicDescriptorOptions<T extends TopicMessageSchema> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<
-  TopicDescriptorOptions<T>
+export class TopicPrimitive<T extends TopicMessageSchema> extends Primitive<
+  TopicPrimitiveOptions<T>
 > {
   protected readonly log = $logger();
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
@@ -336,7 +336,7 @@ export class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<
   }
 }
 
-$topic[KIND] = TopicDescriptor;
+$topic[KIND] = TopicPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/topic/providers/TopicProvider.ts

@@ -1,6 +1,6 @@
 import { $inject, Alepha } from "alepha";
-import { $subscriber } from "../descriptors/$subscriber.ts";
-import { $topic } from "../descriptors/$topic.ts";
+import { $subscriber } from "../primitives/$subscriber.ts";
+import { $topic } from "../primitives/$topic.ts";
 
 /**
  * Base class for topic providers.
@@ -40,7 +40,7 @@ export abstract class TopicProvider {
   protected subscribers(): Array<() => Promise<unknown>> {
     const handlers: Array<() => Promise<unknown>> = [];
 
-    const topics = this.alepha.descriptors($topic);
+    const topics = this.alepha.primitives($topic);
 
     for (const topic of topics) {
       if (topic.provider !== this) {
@@ -53,7 +53,7 @@ export abstract class TopicProvider {
       }
     }
 
-    const subscribers = this.alepha.descriptors($subscriber);
+    const subscribers = this.alepha.primitives($subscriber);
     for (const subscriber of subscribers) {
       if (subscriber.options.topic.provider !== this) {
         continue;

package/src/vite/helpers/boot.ts

@@ -43,10 +43,8 @@ const getServerEntry = async (
   }
 
   const maybeEntry = [
-    "src/index.server.ts",
     "src/main.server.ts",
     "src/server-entry.ts",
-    "src/index.server.tsx",
     "src/main.server.tsx",
     "src/server-entry.tsx",
     "src/main.ts",
@@ -68,7 +66,9 @@ const getServerEntry = async (
     return clientEntry;
   }
 
-  throw new AlephaError(`Could not find a server entry file.`);
+  throw new AlephaError(
+    `Could not find a server entry file. List of supported entry file: ${maybeEntry.join(", ")}`,
+  );
 };
 
 /**

package/src/vite/tasks/copyAssets.ts

@@ -27,7 +27,7 @@ export interface CopyAssetsOptions {
 export async function copyAssets(opts: CopyAssetsOptions): Promise<void> {
   const root = process.cwd();
   const alepha = await importAlepha(opts.entry);
-  const assets = alepha.state.get("alepha.build.assets");
+  const assets = alepha.store.get("alepha.build.assets");
 
   if (!assets || assets.length === 0) {
     return;

package/src/vite/tasks/generateSitemap.ts

@@ -19,10 +19,10 @@ export interface GenerateSitemapOptions {
 }
 
 /**
- * Generate sitemap.xml from Alepha page descriptors.
+ * Generate sitemap.xml from Alepha page primitives.
  *
  * This task loads the built Alepha application,
- * queries all page descriptors, and generates a sitemap.xml
+ * queries all page primitives, and generates a sitemap.xml
  * containing URLs for all accessible pages.
  */
 export async function generateSitemap(
@@ -45,7 +45,7 @@ export async function generateSitemap(
 }
 
 function generateSitemapFromAlepha(alepha: Alepha, baseUrl: string): string {
-  const pages = alepha.descriptors("page") as any[];
+  const pages = alepha.primitives("page") as any[];
   const urls: string[] = [];
 
   for (const page of pages) {

package/src/vite/tasks/prerenderPages.ts

@@ -34,7 +34,7 @@ export interface PrerenderPagesResult {
  * Pre-render static pages defined in the Alepha application.
  *
  * This task loads the built Alepha application, queries all page
- * descriptors with `static: true`, and generates static HTML files
+ * primitives with `static: true`, and generates static HTML files
  * for each page. Supports pages with parameterized routes via
  * `static.entries` configuration.
  */
@@ -59,7 +59,7 @@ async function prerenderFromAlepha(
   compress?: ViteCompressOptions | boolean,
 ): Promise<PrerenderPagesResult> {
   let count = 0;
-  const pages = alepha.descriptors("page") as any[];
+  const pages = alepha.primitives("page") as any[];
 
   for (const page of pages) {
     const options = page.options;

package/src/vite/tasks/runAlepha.ts

@@ -65,7 +65,7 @@ export class AlephaRunner {
   isSsrEnabled(): boolean {
     if (!this.state.app) return false;
     return (
-      (this.state.app.state.get("alepha.react.server.ssr" as keyof State) as
+      (this.state.app.store.get("alepha.react.server.ssr" as keyof State) as
         | boolean
         | undefined) ?? false
     );
@@ -140,7 +140,7 @@ export class AlephaRunner {
         return;
       }
 
-      this.state.app.state.set("alepha.node.server" as any, server.httpServer);
+      this.state.app.store.set("alepha.node.server" as any, server.httpServer);
 
       await this.state.app.start();
       this.state.started = true;

package/src/websocket/index.browser.ts

@@ -1,7 +1,7 @@
 import { $module, type Alepha } from "alepha";
 import { AlephaTopic } from "alepha/topic";
-import { $channel } from "./descriptors/$channel.ts";
-import { $websocket } from "./descriptors/$websocket.ts";
+import { $channel } from "./primitives/$channel.ts";
+import { $websocket } from "./primitives/$websocket.ts";
 import { WebSocketClient } from "./services/WebSocketClient.ts";
 
 /**
@@ -16,7 +16,7 @@ export * from "./index.shared.ts";
 
 export const AlephaWebSocket = $module({
   name: "alepha.websocket",
-  descriptors: [$channel, $websocket],
+  primitives: [$channel, $websocket],
   services: [WebSocketClient],
   register: (alepha: Alepha) => {
     alepha.with(AlephaTopic);

package/src/websocket/index.shared.ts

@@ -1,7 +1,7 @@
-export * from "./descriptors/$channel.ts";
-export * from "./descriptors/$websocket.ts";
 export * from "./errors/WebSocketError.ts";
 export * from "./interfaces/WebSocketInterfaces.ts";
+export * from "./primitives/$channel.ts";
+export * from "./primitives/$websocket.ts";
 export * from "./providers/WebSocketServerProvider.ts";
 export * from "./services/RoomManager.ts";
 export * from "./services/WebSocketClient.ts";

package/src/websocket/index.ts

@@ -1,8 +1,8 @@
 import { $module, type Alepha } from "alepha";
 import { AlephaServer } from "alepha/server";
 import { AlephaTopic } from "alepha/topic";
-import { $channel } from "./descriptors/$channel.ts";
-import { $websocket } from "./descriptors/$websocket.ts";
+import { $channel } from "./primitives/$channel.ts";
+import { $websocket } from "./primitives/$websocket.ts";
 import { NodeWebSocketServerProvider } from "./providers/NodeWebSocketServerProvider.ts";
 import { WebSocketServerProvider } from "./providers/WebSocketServerProvider.ts";
 import { RoomManager } from "./services/RoomManager.ts";
@@ -60,7 +60,7 @@ export * from "./providers/NodeWebSocketServerProvider.ts";
 /**
  * Provides real-time bidirectional communication using WebSockets.
  *
- * The WebSockets module enables building real-time applications using the `$websocket` descriptor
+ * The WebSockets module enables building real-time applications using the `$websocket` primitive
  * on class properties. It provides automatic connection management, message routing, type-safe
  * message handling, and seamless integration with other Alepha modules.
  *
@@ -72,7 +72,7 @@ export * from "./providers/NodeWebSocketServerProvider.ts";
  */
 export const AlephaWebSocket = $module({
   name: "alepha.websocket",
-  descriptors: [$channel, $websocket],
+  primitives: [$channel, $websocket],
   services: [
     WebSocketServerProvider,
     NodeWebSocketServerProvider,