@hypen-space/core 0.4.3 → 0.4.11

package/src/engine.ts

@@ -6,6 +6,7 @@
 // WASM module types
 import { WasmEngine } from "../wasm-node/hypen_engine.js";
 import { frameworkLoggers } from "./logger.js";
+import { classifyEngineError } from "./result.js";
 import type { Patch, Action, RenderCallback, ActionHandler, ResolvedComponent, ComponentResolver } from "./types.js";
 
 // Re-export types so existing consumers of "./engine.js" still work
@@ -89,10 +90,16 @@ export class Engine {
 
   /**
    * Parse and render Hypen DSL source code
+   * @throws {ParseError} if the source fails to parse
+   * @throws {RenderError} if rendering fails
    */
   renderSource(source: string): void {
     const engine = this.ensureInitialized();
-    engine.renderSource(source);
+    try {
+      engine.renderSource(source);
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
 
   /**
@@ -105,14 +112,21 @@ export class Engine {
 
   /**
    * Render a component into a specific parent node (subtree rendering)
+   * @throws {ParseError} if the source fails to parse
+   * @throws {RenderError} if the parent node is not found or rendering fails
    */
   renderInto(source: string, parentNodeId: string, state: Record<string, any>): void {
     const engine = this.ensureInitialized();
-    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+    try {
+      engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
 
   /**
    * Notify the engine of state changes using sparse updates
+   * @throws {StateError} if the state patch is invalid
    */
   notifyStateChange(paths: string[], values: Record<string, any>): void {
     const engine = this.ensureInitialized();
@@ -121,7 +135,11 @@ export class Engine {
       return;
     }
 
-    engine.updateStateSparse(paths, unwrapForWasm(values));
+    try {
+      engine.updateStateSparse(paths, unwrapForWasm(values));
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
     log.debug("State changed (sparse):", paths);
   }
 
@@ -149,10 +167,15 @@ export class Engine {
 
   /**
    * Dispatch an action
+   * @throws {HypenError} if the action dispatch fails
    */
   dispatchAction(name: string, payload?: any): void {
     const engine = this.ensureInitialized();
-    engine.dispatchAction(name, payload ?? null);
+    try {
+      engine.dispatchAction(name, payload ?? null);
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
 
   /**

package/src/index.browser.ts

@@ -28,9 +28,7 @@ export type {
 export { app, HypenApp, HypenAppBuilder, HypenModuleInstance } from "./app.js";
 export type {
   IEngine,
-  RouterContext,
   ActionContext,
-  ActionNext,
   GlobalContext,
   LifecycleHandler,
   ActionHandlerContext,

package/src/index.ts

@@ -74,9 +74,7 @@ export type { StateProxy, ItemProxy } from "./hypen.js";
 
 export type {
   IEngine,
-  RouterContext,
   ActionContext,
-  ActionNext,
   GlobalContext,
   LifecycleHandler,
   ActionHandlerContext,
@@ -245,6 +243,9 @@ export {
   ActionError,
   ConnectionError,
   StateError,
+  ParseError,
+  RenderError,
+  classifyEngineError,
 } from "./result.js";
 export type { Result } from "./result.js";
 

package/src/managed-router.ts

@@ -9,10 +9,9 @@
  */
 
 import type { IEngine, HypenModuleDefinition } from "./app.js";
-import { HypenModuleInstance } from "./app.js";
+import { HypenModuleInstance, HypenApp } from "./app.js";
 import type { HypenRouter, RouteState } from "./router.js";
 import type { HypenGlobalContext } from "./context.js";
-import { ModuleRegistry } from "./module-registry.js";
 import { createLogger } from "./logger.js";
 
 const log = createLogger("ManagedRouter");
@@ -20,7 +19,7 @@ const log = createLogger("ManagedRouter");
 export interface RouteDefinition {
   /** Route path pattern (e.g., "/", "/profile/:id") */
   path: string;
-  /** Component name — used to look up in ModuleRegistry */
+  /** Component name — used to look up in app registry */
   component: string;
   /** Inline module definition (alternative to registry lookup) */
   module?: HypenModuleDefinition;
@@ -29,7 +28,7 @@ export interface RouteDefinition {
 export class ManagedRouter {
   private router: HypenRouter;
   private engine: IEngine;
-  private registry: ModuleRegistry;
+  private registry: HypenApp;
   private globalContext: HypenGlobalContext;
   private routes: RouteDefinition[] = [];
   private activeModule: HypenModuleInstance | null = null;
@@ -41,7 +40,7 @@ export class ManagedRouter {
   constructor(
     router: HypenRouter,
     engine: IEngine,
-    registry: ModuleRegistry,
+    registry: HypenApp,
     globalContext: HypenGlobalContext
   ) {
     this.router = router;
@@ -161,7 +160,7 @@ export class ManagedRouter {
     const instance = new HypenModuleInstance(
       this.engine,
       namedDef as HypenModuleDefinition<object>,
-      { root: this.router },
+      this.router,
       this.globalContext
     );
 

package/src/remote/server.ts

@@ -1,36 +1,36 @@
 /**
  * RemoteServer - Stream Hypen apps over WebSocket with Session Management
  *
- * Usage:
+ * Usage with inline UI:
  * ```typescript
  * import { RemoteServer, app } from "@hypen-space/core";
  *
  * const counter = app
  *   .defineState({ count: 0 })
  *   .onAction("increment", ({ state }) => state.count++)
- *   .onDisconnect(async ({ state, session }) => {
- *     await redis.set(`session:${session.id}`, JSON.stringify(state));
- *   })
- *   .onReconnect(async ({ session, restore }) => {
- *     const saved = await redis.get(`session:${session.id}`);
- *     if (saved) restore(JSON.parse(saved));
- *   })
- *   .onExpire(async ({ session }) => {
- *     await redis.del(`session:${session.id}`);
- *   })
  *   .build();
  *
  * new RemoteServer()
  *   .module("Counter", counter)
  *   .ui(`Column { Text("Count: \${state.count}") }`)
- *   .session({ ttl: 3600, concurrent: "kick-old" })
  *   .listen(3000);
  * ```
+ *
+ * Usage with directory-based discovery (auto-resolves imports):
+ * ```typescript
+ * import { RemoteServer } from "@hypen-space/core";
+ * import chatModule from "./apps/chat/Chat/component.js";
+ *
+ * await new RemoteServer()
+ *   .source("./apps/chat")
+ *   .module("Chat", chatModule)
+ *   .listen(3001);
+ * ```
  */
 
 import { Engine } from "../engine.js";
 import { HypenModuleInstance } from "../app.js";
-import type { HypenModule } from "../app.js";
+import type { HypenModule, HypenModuleDefinition } from "../app.js";
 import type {
   RemoteMessage,
   RemoteClient,
@@ -44,10 +44,15 @@ import type {
   Session,
   SessionConfig,
 } from "./types.js";
-import type { Patch } from "../types.js";
+import type { Patch, ResolvedComponent } from "../types.js";
 import type { ServerWebSocket } from "bun";
 import { SessionManager } from "./session.js";
 import { frameworkLoggers } from "../logger.js";
+import {
+  discoverComponents,
+  loadDiscoveredComponents,
+  type DiscoveredComponent,
+} from "../discovery.js";
 
 const log = frameworkLoggers.remote;
 
@@ -72,6 +77,8 @@ export class RemoteServer {
   private _module: HypenModule<any> | null = null;
   private _moduleName: string = "App";
   private _ui: string = "";
+  private _sourceDir: string | null = null;
+  private _discoveredComponents: Map<string, { template: string; module?: HypenModuleDefinition<any> }> = new Map();
   private _config: RemoteServerConfig = {};
   private _sessionConfig: SessionConfig = {};
   private _onConnectionCallbacks: Array<(client: RemoteClient) => void> = [];
@@ -98,6 +105,26 @@ export class RemoteServer {
     return this;
   }
 
+  /**
+   * Set a source directory for automatic component discovery.
+   *
+   * All .hypen and .ts components in the directory (and subdirectories) are
+   * discovered automatically. The entry component's template is used as the
+   * UI, so calling .ui() is optional when .source() is set.
+   *
+   * @example
+   * ```typescript
+   * new RemoteServer()
+   *   .source("./apps/chat")
+   *   .module("Chat", chatModule)
+   *   .listen(3001);
+   * ```
+   */
+  source(dir: string): this {
+    this._sourceDir = dir;
+    return this;
+  }
+
   /**
    * Set server configuration
    */
@@ -133,13 +160,20 @@ export class RemoteServer {
   /**
    * Start the WebSocket server
    */
-  listen(port?: number): this {
+  async listen(port?: number): Promise<this> {
     if (!this._module) {
       throw new Error("Module not set. Call .module() before .listen()");
     }
 
+    // Run component discovery if source directory is set
+    if (this._sourceDir) {
+      await this.discoverFromSource();
+    }
+
     if (!this._ui) {
-      throw new Error("UI not set. Call .ui() before .listen()");
+      throw new Error(
+        "UI not set. Call .ui() or .source() before .listen()"
+      );
     }
 
     // Initialize session manager
@@ -214,6 +248,56 @@ export class RemoteServer {
     return `ws://${hostname}:${port}`;
   }
 
+  /**
+   * Discover components from the source directory.
+   * Populates _discoveredComponents and sets _ui from the entry component
+   * if not already set via .ui().
+   */
+  private async discoverFromSource(): Promise<void> {
+    const dir = this._sourceDir!;
+    log.info(`Discovering components from ${dir}...`);
+
+    const discovered = await discoverComponents(dir);
+    const loaded = await loadDiscoveredComponents(discovered);
+
+    for (const [name, { module, template }] of loaded) {
+      this._discoveredComponents.set(name, { template, module });
+    }
+
+    log.info(
+      `Discovered ${this._discoveredComponents.size} components: ${Array.from(this._discoveredComponents.keys()).join(", ")}`
+    );
+
+    // If .ui() was not called, use the entry component's template
+    if (!this._ui) {
+      const entry = this._discoveredComponents.get(this._moduleName);
+      if (entry) {
+        this._ui = entry.template;
+      }
+    }
+  }
+
+  /**
+   * Set up a component resolver on a client engine so that imports
+   * and component references in templates are resolved from discovered
+   * components.
+   */
+  private setupComponentResolver(engine: Engine): void {
+    if (this._discoveredComponents.size === 0) return;
+
+    engine.setComponentResolver(
+      (componentName: string, _contextPath: string | null) => {
+        const comp = this._discoveredComponents.get(componentName);
+        if (!comp) return null;
+
+        return {
+          source: comp.template,
+          path: componentName,
+        };
+      }
+    );
+  }
+
   /**
    * Handle new WebSocket connection
    * Waits for hello message before fully initializing
@@ -227,6 +311,9 @@ export class RemoteServer {
       const engine = new Engine();
       await engine.init();
 
+      // Wire up component resolver if we have discovered components
+      this.setupComponentResolver(engine);
+
       // Create module instance
       const moduleInstance = new HypenModuleInstance(engine, this._module!);
 
@@ -618,19 +705,27 @@ export class RemoteServer {
 /**
  * Convenience function to create and start a RemoteServer
  */
-export function serve(options: {
+export async function serve(options: {
   module: HypenModule<any>;
   moduleName?: string;
-  ui: string;
+  ui?: string;
+  source?: string;
   port?: number;
   hostname?: string;
   session?: SessionConfig;
   onConnection?: (client: RemoteClient) => void;
   onDisconnection?: (client: RemoteClient) => void;
-}): RemoteServer {
+}): Promise<RemoteServer> {
   const server = new RemoteServer()
-    .module(options.moduleName ?? "App", options.module)
-    .ui(options.ui);
+    .module(options.moduleName ?? "App", options.module);
+
+  if (options.source) {
+    server.source(options.source);
+  }
+
+  if (options.ui) {
+    server.ui(options.ui);
+  }
 
   if (options.port || options.hostname) {
     server.config({

package/src/result.ts

@@ -258,3 +258,51 @@ export class StateError extends HypenError {
     this.path = path;
   }
 }
+
+/**
+ * Error thrown when parsing Hypen DSL source fails
+ */
+export class ParseError extends HypenError {
+  readonly source?: string;
+
+  constructor(message: string, source?: string, cause?: unknown) {
+    super('PARSE_ERROR', message, {
+      context: { source },
+      cause: cause instanceof Error ? cause : undefined,
+    });
+    this.name = 'ParseError';
+    this.source = source;
+  }
+}
+
+/**
+ * Error thrown when rendering fails
+ */
+export class RenderError extends HypenError {
+  constructor(message: string, cause?: unknown) {
+    super('RENDER_ERROR', message, {
+      cause: cause instanceof Error ? cause : undefined,
+    });
+    this.name = 'RenderError';
+  }
+}
+
+/**
+ * Classify a WASM engine error string into the appropriate HypenError subclass.
+ * The engine returns JsValue error strings with known prefixes.
+ */
+export function classifyEngineError(err: unknown): HypenError {
+  const message = err instanceof Error ? err.message : String(err);
+
+  if (message.startsWith('Parse error:')) {
+    return new ParseError(message);
+  }
+  if (message.startsWith('Invalid state:') || message.startsWith('Invalid state patch:')) {
+    return new StateError(message);
+  }
+  if (message.startsWith('Parent node not found:')) {
+    return new RenderError(message);
+  }
+
+  return new RenderError(message);
+}

package/src/types.ts

@@ -6,7 +6,7 @@
  */
 
 export type Patch = {
-  type: "create" | "setProp" | "setText" | "insert" | "move" | "remove" | "attachEvent" | "detachEvent";
+  type: "create" | "setProp" | "removeProp" | "setText" | "insert" | "move" | "remove" | "attachEvent" | "detachEvent";
   id?: string;
   elementType?: string;
   props?: Record<string, any>;

package/wasm-browser/hypen_engine.d.ts

@@ -120,11 +120,11 @@ export interface InitOutput {
   readonly parseToJson: (a: number, b: number) => [number, number, number, number];
   readonly main: () => void;
   readonly wasmengine_renderSource: (a: number, b: number, c: number) => [number, number];
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_4: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;

package/wasm-browser/hypen_engine.js

@@ -30,9 +30,72 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_2.set(idx, obj);
+    wasm.__wbindgen_export_4.set(idx, obj);
     return idx;
 }
 
@@ -54,15 +117,6 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -128,62 +182,8 @@ function debugString(val) {
     return className;
 }
 
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    }
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
+    const value = wasm.__wbindgen_export_4.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
@@ -509,6 +509,13 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
         const ret = arg0.call(arg1);
         return ret;
@@ -727,7 +734,7 @@ function __wbg_get_imports() {
         return ret;
     };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_2;
+        const table = wasm.__wbindgen_export_4;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);

package/wasm-browser/hypen_engine_bg.wasm.d.ts

@@ -20,11 +20,11 @@ export const patchesToJson: (a: any) => [number, number, number, number];
 export const parseToJson: (a: number, b: number) => [number, number, number, number];
 export const main: () => void;
 export const wasmengine_renderSource: (a: number, b: number, c: number) => [number, number];
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
-export const __wbindgen_export_2: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_export_4: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
 export const __wbindgen_start: () => void;

package/wasm-browser/package.json

@@ -5,7 +5,7 @@
     "Hypen Contributors"
   ],
   "description": "A Rust implementation of the Hypen engine",
-  "version": "0.4.1",
+  "version": "0.4.11",
   "license": "MIT",
   "repository": {
     "type": "git",