@hypen-space/core 0.2.0

package/dist/chunk-5va59f7m.js

@@ -0,0 +1,22 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM, __require };
+
+//# debugId=139229FD8440C0D464756E2164756E21

package/dist/chunk-5va59f7m.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "139229FD8440C0D464756E2164756E21",
+  "names": []
+}

package/dist/engine.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Low-level wrapper around the WASM engine
+ * Node.js / Bundler target
+ */
+export declare type Patch = {
+    type: "create" | "setProp" | "setText" | "insert" | "move" | "remove" | "attachEvent" | "detachEvent";
+    id?: string;
+    elementType?: string;
+    props?: Record<string, any>;
+    name?: string;
+    value?: any;
+    text?: string;
+    parentId?: string;
+    beforeId?: string;
+    eventName?: string;
+};
+export declare type Action = {
+    name: string;
+    payload?: any;
+    sender?: string;
+};
+export declare type RenderCallback = (patches: Patch[]) => void;
+export declare type ActionHandler = (action: Action) => void | Promise<void>;
+export declare type ResolvedComponent = {
+    source: string;
+    path: string;
+};
+export declare type ComponentResolver = (componentName: string, contextPath: string | null) => ResolvedComponent | null;
+/**
+ * Engine wraps the WASM engine and provides a TypeScript-friendly API
+ */
+export declare class Engine {
+    private wasmEngine;
+    private initialized;
+    /**
+     * Initialize the WASM module
+     */
+    init(): Promise<void>;
+    /**
+     * Ensure the engine is initialized before operations
+     */
+    private ensureInitialized;
+    /**
+     * Set the render callback that receives patches
+     */
+    setRenderCallback(callback: RenderCallback): void;
+    /**
+     * Set the component resolver for dynamic component composition
+     */
+    setComponentResolver(resolver: ComponentResolver): void;
+    /**
+     * Parse and render Hypen DSL source code
+     */
+    renderSource(source: string): void;
+    /**
+     * Render a lazy component (for lazy route loading)
+     */
+    renderLazyComponent(source: string): void;
+    /**
+     * Render a component into a specific parent node (subtree rendering)
+     */
+    renderInto(source: string, parentNodeId: string, state: Record<string, any>): void;
+    /**
+     * Notify the engine of state changes using sparse updates
+     */
+    notifyStateChange(paths: string[], values: Record<string, any>): void;
+    /**
+     * Notify the engine of state changes using full state replacement
+     * @deprecated Use notifyStateChange with sparse values instead
+     */
+    notifyStateChangeFull(paths: string[], currentState: Record<string, any>): void;
+    /**
+     * Update state (triggers re-render of affected nodes)
+     * @deprecated Use notifyStateChange instead
+     */
+    updateState(statePatch: Record<string, any>): void;
+    /**
+     * Dispatch an action
+     */
+    dispatchAction(name: string, payload?: any): void;
+    /**
+     * Register an action handler
+     */
+    onAction(actionName: string, handler: ActionHandler): void;
+    /**
+     * Initialize a module
+     */
+    setModule(name: string, actions: string[], stateKeys: string[], initialState: Record<string, any>): void;
+    /**
+     * Get the current revision number
+     */
+    getRevision(): number;
+    /**
+     * Clear the engine tree
+     */
+    clearTree(): void;
+    /**
+     * Debug method to inspect parsed components
+     */
+    debugParseComponent(source: string): string;
+}

package/dist/events.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Type-safe Event System
+ *
+ * Provides strongly-typed event emission and subscription with autocomplete support.
+ */
+export declare type EventHandler<T = unknown> = (payload: T) => void;
+/**
+ * Type-safe event emitter with generics
+ */
+export declare class TypedEventEmitter<TEvents extends Record<string, unknown> = Record<string, unknown>> {
+    private eventBus;
+    /**
+     * Emit an event with type-safe payload
+     */
+    emit<K extends keyof TEvents>(event: K, payload: TEvents[K]): void;
+    /**
+     * Subscribe to an event with type-safe payload
+     * Returns an unsubscribe function
+     */
+    on<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): () => void;
+    /**
+     * Subscribe to an event once (auto-unsubscribe after first emit)
+     */
+    once<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): () => void;
+    /**
+     * Unsubscribe a specific handler from an event
+     */
+    off<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void;
+    /**
+     * Remove all listeners for a specific event
+     */
+    removeAllListeners<K extends keyof TEvents>(event: K): void;
+    /**
+     * Remove all listeners for all events
+     */
+    clearAll(): void;
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount<K extends keyof TEvents>(event: K): number;
+    /**
+     * Get all registered event names
+     */
+    eventNames(): Array<keyof TEvents>;
+}
+/**
+ * Default events for Hypen framework (can be extended by users)
+ */
+export declare type HypenFrameworkEvents = {
+    'module:created': {
+        moduleId: string;
+    };
+    'module:destroyed': {
+        moduleId: string;
+    };
+    'route:changed': {
+        from: string | null;
+        to: string;
+    };
+    'state:updated': {
+        moduleId: string;
+        paths: string[];
+    };
+    'action:dispatched': {
+        moduleId: string;
+        actionName: string;
+        payload?: unknown;
+    };
+    'error': {
+        message: string;
+        error?: Error;
+        context?: string;
+    };
+};
+/**
+ * Create a typed event emitter with custom event map
+ */
+export declare function createEventEmitter<TEvents extends Record<string, unknown> = HypenFrameworkEvents>(): TypedEventEmitter<TEvents>;

package/dist/index.browser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @hypen/core - Browser Entry Point
+ *
+ * This entry point uses the browser-compatible engine with explicit WASM initialization.
+ */
+export { Engine } from "./engine.browser.js";
+export { app, HypenApp, HypenAppBuilder, HypenModuleInstance } from "./app.js";
+export { createObservableState, batchStateUpdates, getStateSnapshot, } from "./state.js";
+export { BaseRenderer, ConsoleRenderer } from "./renderer.js";
+export { HypenRouter } from "./router.js";
+export { TypedEventEmitter, createEventEmitter } from "./events.js";
+export { HypenGlobalContext } from "./context.js";
+export { RemoteEngine } from "./remote/client.js";

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @hypen/core - Hypen Core Engine
+ *
+ * Platform-agnostic reactive UI runtime.
+ * Use with @hypen/web for browser rendering, or build your own renderer.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { Engine, app } from "@hypen/core";
+ *
+ * // Create a stateful module
+ * const counter = app
+ *   .defineState({ count: 0 })
+ *   .onAction("increment", ({ state }) => {
+ *     state.count++;
+ *   })
+ *   .build();
+ *
+ * // Initialize the engine
+ * const engine = new Engine();
+ * await engine.init();
+ * ```
+ */
+export { Engine } from "./engine.js";
+export { Engine as BrowserEngine } from "./engine.browser.js";
+export { app, HypenApp, HypenAppBuilder, HypenModuleInstance } from "./app.js";
+export { createObservableState, batchStateUpdates, getStateSnapshot, } from "./state.js";
+export { BaseRenderer, ConsoleRenderer } from "./renderer.js";
+export { HypenRouter } from "./router.js";
+export { TypedEventEmitter, createEventEmitter } from "./events.js";
+export { HypenGlobalContext } from "./context.js";
+export { RemoteEngine } from "./remote/client.js";

package/dist/remote/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remote UI streaming for Hypen
+ *
+ * Client-side: Connect to remote Hypen apps
+ */
+export { RemoteEngine } from "./client.js";

package/dist/router.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Hypen Router - Declarative routing system
+ * Integrated with Hypen's reactive state management
+ */
+export declare type RouteMatch = {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    path: string;
+};
+export declare type RouteState = {
+    currentPath: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    previousPath: string | null;
+};
+export declare type RouteChangeCallback = (route: RouteState) => void;
+/**
+ * Hypen Router - Manages application routing with pattern matching
+ */
+export declare class HypenRouter {
+    private state;
+    private subscribers;
+    private isInitialized;
+    constructor();
+    /**
+     * Initialize browser history sync
+     */
+    private initializeBrowserSync;
+    /**
+     * Get path from browser URL (supports both hash and pathname)
+     */
+    private getPathFromBrowser;
+    /**
+     * Parse query string from URL
+     */
+    private parseQuery;
+    /**
+     * Navigate to a new path
+     */
+    push(path: string): void;
+    /**
+     * Replace current path without adding to history
+     */
+    replace(path: string): void;
+    /**
+     * Go back in history
+     */
+    back(): void;
+    /**
+     * Go forward in history
+     */
+    forward(): void;
+    /**
+     * Update the current path
+     */
+    private updatePath;
+    /**
+     * Get current path
+     */
+    getCurrentPath(): string;
+    /**
+     * Get current route params
+     */
+    getParams(): Record<string, string>;
+    /**
+     * Get current query params
+     */
+    getQuery(): Record<string, string>;
+    /**
+     * Get full route state snapshot
+     */
+    getState(): RouteState;
+    /**
+     * Match a pattern against a path
+     */
+    matchPath(pattern: string, path: string): RouteMatch | null;
+    /**
+     * Subscribe to route changes
+     */
+    onNavigate(callback: RouteChangeCallback): () => void;
+    /**
+     * Notify all subscribers of route change
+     */
+    private notifySubscribers;
+    /**
+     * Check if a path matches the current route
+     */
+    isActive(pattern: string): boolean;
+    /**
+     * Get a URL with query params
+     */
+    buildUrl(path: string, query?: Record<string, string>): string;
+}

package/dist/src/app.js

@@ -0,0 +1,160 @@
+import {
+  createObservableState,
+  getStateSnapshot
+} from "./state.js";
+import"../chunk-5va59f7m.js";
+
+// src/app.ts
+class HypenAppBuilder {
+  initialState;
+  options;
+  createdHandler;
+  actionHandlers = new Map;
+  destroyedHandler;
+  constructor(initialState, options) {
+    this.initialState = initialState;
+    this.options = options || {};
+  }
+  onCreated(fn) {
+    this.createdHandler = fn;
+    return this;
+  }
+  onAction(name, fn) {
+    this.actionHandlers.set(name, fn);
+    return this;
+  }
+  onDestroyed(fn) {
+    this.destroyedHandler = fn;
+    return this;
+  }
+  build() {
+    const stateKeys = this.initialState !== null && typeof this.initialState === "object" ? Object.keys(this.initialState) : [];
+    return {
+      name: this.options.name,
+      actions: Array.from(this.actionHandlers.keys()),
+      stateKeys,
+      persist: this.options.persist,
+      version: this.options.version,
+      initialState: this.initialState,
+      handlers: {
+        onCreated: this.createdHandler,
+        onAction: this.actionHandlers,
+        onDestroyed: this.destroyedHandler
+      }
+    };
+  }
+}
+
+class HypenApp {
+  defineState(initial, options) {
+    return new HypenAppBuilder(initial, options);
+  }
+}
+var app = new HypenApp;
+
+class HypenModuleInstance {
+  engine;
+  definition;
+  state;
+  isDestroyed = false;
+  routerContext;
+  globalContext;
+  stateChangeCallbacks = [];
+  constructor(engine, definition, routerContext, globalContext) {
+    this.engine = engine;
+    this.definition = definition;
+    this.routerContext = routerContext;
+    this.globalContext = globalContext;
+    this.state = createObservableState(definition.initialState, {
+      onChange: (change) => {
+        this.engine.notifyStateChange(change.paths, change.newValues);
+        this.stateChangeCallbacks.forEach((cb) => cb());
+      }
+    });
+    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
+    for (const [actionName, handler] of definition.handlers.onAction) {
+      console.log(`[ModuleInstance] Registering action handler: ${actionName} for module ${definition.name}`);
+      this.engine.onAction(actionName, async (action) => {
+        console.log(`[ModuleInstance] Action handler fired: ${actionName}`, action);
+        const actionCtx = {
+          name: action.name,
+          payload: action.payload,
+          sender: action.sender
+        };
+        const next = {
+          router: this.routerContext?.root || null
+        };
+        const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
+        try {
+          await handler({
+            action: actionCtx,
+            state: this.state,
+            next,
+            context
+          });
+          console.log(`[ModuleInstance] Action handler completed: ${actionName}`);
+        } catch (error) {
+          console.error(`[ModuleInstance] Action handler error for ${actionName}:`, error);
+        }
+      });
+    }
+    this.callCreatedHandler();
+  }
+  createGlobalContextAPI() {
+    if (!this.globalContext) {
+      throw new Error("Global context not available");
+    }
+    const ctx = this.globalContext;
+    const api = {
+      getModule: (id) => ctx.getModule(id),
+      hasModule: (id) => ctx.hasModule(id),
+      getModuleIds: () => ctx.getModuleIds(),
+      getGlobalState: () => ctx.getGlobalState(),
+      emit: (event, payload) => ctx.emit(event, payload),
+      on: (event, handler) => ctx.on(event, handler)
+    };
+    if (ctx.__router) {
+      api.__router = ctx.__router;
+    }
+    if (ctx.__hypenEngine) {
+      api.__hypenEngine = ctx.__hypenEngine;
+    }
+    return api;
+  }
+  async callCreatedHandler() {
+    if (this.definition.handlers.onCreated) {
+      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
+      await this.definition.handlers.onCreated(this.state, context);
+    }
+  }
+  onStateChange(callback) {
+    this.stateChangeCallbacks.push(callback);
+  }
+  async destroy() {
+    if (this.isDestroyed)
+      return;
+    if (this.definition.handlers.onDestroyed) {
+      await this.definition.handlers.onDestroyed(this.state);
+    }
+    this.isDestroyed = true;
+  }
+  getState() {
+    return getStateSnapshot(this.state);
+  }
+  getLiveState() {
+    return this.state;
+  }
+  updateState(patch) {
+    Object.assign(this.state, patch);
+  }
+}
+export {
+  app,
+  HypenModuleInstance,
+  HypenAppBuilder,
+  HypenApp
+};
+
+export { HypenAppBuilder, HypenApp, app, HypenModuleInstance };
+
+//# debugId=220ACA4FDA4DC86164756E2164756E21

package/dist/src/app.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/app.ts"],
+  "sourcesContent": [
+    "/**\n * Hypen App Builder API\n * Implements the stateful module system from RFC-0001\n */\n\nimport type { Action } from \"./engine.js\";\n\n// Interface for engine compatibility (works with both engine.js and engine.browser.js)\nexport interface IEngine {\n  setModule(name: string, actions: string[], stateKeys: string[], initialState: unknown): void;\n  onAction(actionName: string, handler: (action: Action) => void | Promise<void>): void;\n  notifyStateChange(paths: string[], changedValues: Record<string, unknown>): void;\n}\n\nimport { createObservableState, type StateChange, getStateSnapshot } from \"./state.js\";\nimport type { HypenRouter } from \"./router.js\";\nimport type { HypenGlobalContext, ModuleReference } from \"./context.js\";\n\nexport type RouterContext = {\n  root: HypenRouter;\n  current?: HypenRouter;\n  parent?: HypenRouter;\n};\n\nexport type ActionContext = {\n  name: string;\n  payload?: unknown;\n  sender?: string;\n};\n\nexport type ActionNext = {\n  router: HypenRouter; // Direct access to router instance (from nearest parent)\n};\n\nexport type GlobalContext = {\n  getModule: <T = unknown>(id: string) => ModuleReference<T>;\n  hasModule: (id: string) => boolean;\n  getModuleIds: () => string[];\n  getGlobalState: () => Record<string, unknown>;\n  emit: (event: string, payload?: unknown) => void;\n  on: (event: string, handler: (payload?: unknown) => void) => () => void;\n  __router?: unknown; // Internal: router instance for built-in Router component\n};\n\nexport type LifecycleHandler<T> = (\n  state: T,\n  context?: GlobalContext\n) => void | Promise<void>;\n\n/**\n * Action handler context - all parameters available explicitly\n */\nexport interface ActionHandlerContext<T> {\n  action: ActionContext;\n  state: T;\n  next: ActionNext;\n  context: GlobalContext;\n}\n\n/**\n * Action handler - receives all context in a single object\n */\nexport type ActionHandler<T> = (ctx: ActionHandlerContext<T>) => void | Promise<void>;\n\nexport interface HypenModuleDefinition<T = unknown> {\n  name?: string;\n  actions: string[];\n  stateKeys: string[];\n  persist?: boolean;\n  version?: number;\n  initialState: T;\n  handlers: {\n    onCreated?: LifecycleHandler<T>;\n    onAction: Map<string, ActionHandler<T>>;\n    onDestroyed?: LifecycleHandler<T>;\n  };\n}\n\n/**\n * Alias for HypenModuleDefinition for backward compatibility\n */\nexport type HypenModule<T = unknown> = HypenModuleDefinition<T>;\n\n/**\n * Builder for creating Hypen app modules\n */\nexport class HypenAppBuilder<T> {\n  private initialState: T;\n  private options: { persist?: boolean; version?: number; name?: string };\n  private createdHandler?: LifecycleHandler<T>;\n  private actionHandlers: Map<string, ActionHandler<T>> = new Map();\n  private destroyedHandler?: LifecycleHandler<T>;\n\n  constructor(\n    initialState: T,\n    options?: { persist?: boolean; version?: number; name?: string }\n  ) {\n    this.initialState = initialState;\n    this.options = options || {};\n  }\n\n  /**\n   * Register a handler for module creation\n   */\n  onCreated(fn: LifecycleHandler<T>): this {\n    this.createdHandler = fn;\n    return this;\n  }\n\n  /**\n   * Register a handler for a specific action\n   */\n  onAction(name: string, fn: ActionHandler<T>): this {\n    this.actionHandlers.set(name, fn);\n    return this;\n  }\n\n  /**\n   * Register a handler for module destruction\n   */\n  onDestroyed(fn: LifecycleHandler<T>): this {\n    this.destroyedHandler = fn;\n    return this;\n  }\n\n  /**\n   * Build the module definition\n   */\n  build(): HypenModuleDefinition<T> {\n    // Safe way to get keys from initialState\n    const stateKeys = this.initialState !== null && typeof this.initialState === 'object'\n      ? Object.keys(this.initialState)\n      : [];\n\n    return {\n      name: this.options.name,\n      actions: Array.from(this.actionHandlers.keys()),\n      stateKeys,\n      persist: this.options.persist,\n      version: this.options.version,\n      initialState: this.initialState,\n      handlers: {\n        onCreated: this.createdHandler,\n        onAction: this.actionHandlers,\n        onDestroyed: this.destroyedHandler,\n      },\n    };\n  }\n}\n\n/**\n * Hypen App API\n */\nexport class HypenApp {\n  /**\n   * Define the initial state for a module\n   */\n  defineState<T>(\n    initial: T,\n    options?: { persist?: boolean; version?: number; name?: string }\n  ): HypenAppBuilder<T> {\n    return new HypenAppBuilder(initial, options);\n  }\n}\n\n/**\n * The main app instance for creating modules\n */\nexport const app = new HypenApp();\n\n/**\n * Module Instance - manages a running module with typed state\n */\nexport class HypenModuleInstance<T extends object = any> {\n  private engine: IEngine;\n  private definition: HypenModuleDefinition<T>;\n  private state: T;\n  private isDestroyed = false;\n  private routerContext?: RouterContext;\n  private globalContext?: HypenGlobalContext;\n  private stateChangeCallbacks: Array<() => void> = [];\n\n  constructor(\n    engine: IEngine,\n    definition: HypenModuleDefinition<T>,\n    routerContext?: RouterContext,\n    globalContext?: HypenGlobalContext\n  ) {\n    this.engine = engine;\n    this.definition = definition;\n    this.routerContext = routerContext;\n    this.globalContext = globalContext;\n\n    // Create observable state that sends only changed paths and values to engine\n    this.state = createObservableState<T>(definition.initialState as T & object, {\n      onChange: (change: StateChange) => {\n        // Send only the changed paths and their new values (not the whole state)\n        this.engine.notifyStateChange(change.paths, change.newValues);\n        // Notify all registered callbacks\n        this.stateChangeCallbacks.forEach(cb => cb());\n      },\n    });\n\n    // Register with engine (initial state registration)\n    this.engine.setModule(\n      definition.name || \"AnonymousModule\",\n      definition.actions,\n      definition.stateKeys,\n      getStateSnapshot(this.state)\n    );\n\n    // Register action handlers with flexible parameter support\n    for (const [actionName, handler] of definition.handlers.onAction) {\n      console.log(`[ModuleInstance] Registering action handler: ${actionName} for module ${definition.name}`);\n      this.engine.onAction(actionName, async (action: Action) => {\n        console.log(`[ModuleInstance] Action handler fired: ${actionName}`, action);\n\n        const actionCtx: ActionContext = {\n          name: action.name,\n          payload: action.payload,\n          sender: action.sender,\n        };\n\n        const next: ActionNext = {\n          router: this.routerContext?.root || (null as any),\n        };\n\n        const context: GlobalContext | undefined = this.globalContext\n          ? this.createGlobalContextAPI()\n          : undefined;\n\n        try {\n          await handler({\n            action: actionCtx,\n            state: this.state,\n            next,\n            context: context!,\n          });\n          console.log(`[ModuleInstance] Action handler completed: ${actionName}`);\n        } catch (error) {\n          console.error(`[ModuleInstance] Action handler error for ${actionName}:`, error);\n        }\n      });\n    }\n\n    // Call onCreated\n    this.callCreatedHandler();\n  }\n\n  /**\n   * Create the global context API for this module\n   */\n  private createGlobalContextAPI(): GlobalContext {\n    if (!this.globalContext) {\n      throw new Error(\"Global context not available\");\n    }\n\n    const ctx = this.globalContext;\n    const api: GlobalContext = {\n      getModule: (id: string) => ctx.getModule(id),\n      hasModule: (id: string) => ctx.hasModule(id),\n      getModuleIds: () => ctx.getModuleIds(),\n      getGlobalState: () => ctx.getGlobalState(),\n      emit: (event: string, payload?: any) => ctx.emit(event, payload),\n      on: (event: string, handler: (payload?: any) => void) =>\n        ctx.on(event, handler),\n    };\n\n    // Expose router and hypen engine for built-in components (if available)\n    if ((ctx as any).__router) {\n      api.__router = (ctx as any).__router;\n    }\n    if ((ctx as any).__hypenEngine) {\n      (api as any).__hypenEngine = (ctx as any).__hypenEngine;\n    }\n\n    return api;\n  }\n\n  /**\n   * Call the onCreated handler\n   */\n  private async callCreatedHandler(): Promise<void> {\n    if (this.definition.handlers.onCreated) {\n      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;\n      await this.definition.handlers.onCreated(this.state, context);\n    }\n  }\n\n  /**\n   * Register a callback to be notified when state changes\n   */\n  onStateChange(callback: () => void): void {\n    this.stateChangeCallbacks.push(callback);\n  }\n\n  /**\n   * Destroy the module instance\n   */\n  async destroy(): Promise<void> {\n    if (this.isDestroyed) return;\n\n    if (this.definition.handlers.onDestroyed) {\n      await this.definition.handlers.onDestroyed(this.state);\n    }\n\n    this.isDestroyed = true;\n  }\n\n  /**\n   * Get the current state (returns a snapshot)\n   */\n  getState(): T {\n    return getStateSnapshot(this.state);\n  }\n\n  /**\n   * Get the live observable state\n   */\n  getLiveState(): T {\n    return this.state;\n  }\n\n  /**\n   * Update state directly (merges with existing state)\n   */\n  updateState(patch: Partial<T>): void {\n    Object.assign(this.state, patch);\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "220ACA4FDA4DC86164756E2164756E21",
+  "names": []
+}

package/dist/src/context.js

@@ -0,0 +1,114 @@
+import {
+  TypedEventEmitter
+} from "./events.js";
+import"../chunk-5va59f7m.js";
+
+// src/context.ts
+class HypenGlobalContext {
+  modules = new Map;
+  typedEvents;
+  legacyEventBus = new Map;
+  constructor() {
+    this.typedEvents = new TypedEventEmitter;
+  }
+  get events() {
+    return this.typedEvents;
+  }
+  registerModule(id, instance) {
+    if (this.modules.has(id)) {
+      console.warn(`Module "${id}" is already registered. Overwriting.`);
+    }
+    this.modules.set(id, instance);
+    console.log(`Registered module: ${id}`);
+  }
+  unregisterModule(id) {
+    this.modules.delete(id);
+    console.log(`Unregistered module: ${id}`);
+  }
+  getModule(id) {
+    const module = this.modules.get(id);
+    if (!module) {
+      throw new Error(`Module "${id}" not found. Available modules: ${Array.from(this.modules.keys()).join(", ")}`);
+    }
+    return {
+      state: module.getLiveState(),
+      setState: (patch) => module.updateState(patch),
+      getState: () => module.getState()
+    };
+  }
+  hasModule(id) {
+    return this.modules.has(id);
+  }
+  getModuleIds() {
+    return Array.from(this.modules.keys());
+  }
+  getGlobalState() {
+    const state = {};
+    this.modules.forEach((module, id) => {
+      state[id] = module.getState();
+    });
+    return state;
+  }
+  emit(event, payload) {
+    const handlers = this.legacyEventBus.get(event);
+    if (!handlers || handlers.size === 0) {
+      console.log(`Event "${event}" emitted but no listeners`);
+    } else {
+      console.log(`Emitting event: ${event}`, payload);
+      handlers.forEach((handler) => {
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error(`Error in event handler for "${event}":`, error);
+        }
+      });
+    }
+    if (this.typedEvents.listenerCount(event) > 0) {
+      this.typedEvents.emit(event, payload);
+    }
+  }
+  on(event, handler) {
+    if (!this.legacyEventBus.has(event)) {
+      this.legacyEventBus.set(event, new Set);
+    }
+    const handlers = this.legacyEventBus.get(event);
+    handlers.add(handler);
+    console.log(`Listening to event: ${event}`);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.legacyEventBus.delete(event);
+      }
+    };
+  }
+  off(event, handler) {
+    const handlers = this.legacyEventBus.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.legacyEventBus.delete(event);
+      }
+    }
+  }
+  clearEvent(event) {
+    this.legacyEventBus.delete(event);
+  }
+  clearAllEvents() {
+    this.legacyEventBus.clear();
+  }
+  debug() {
+    return {
+      modules: this.getModuleIds(),
+      events: Array.from(this.legacyEventBus.keys()),
+      typedEvents: this.typedEvents.eventNames(),
+      state: this.getGlobalState()
+    };
+  }
+}
+export {
+  HypenGlobalContext
+};
+
+export { HypenGlobalContext };
+
+//# debugId=C15ABCA30BB35BCF64756E2164756E21