From fb190878b21e9e298a1185b9b42f9cbc99fd2277 Mon Sep 17 00:00:00 2001
From: SrGooglo <srgooglo@ragestudio.net>
Date: Thu, 6 Mar 2025 03:45:30 +0000
Subject: [PATCH] merge from 0.20

---
 .gitignore                                   |   3 +-
 package.json                                 |  54 +-
 src/classes/CoresManager/index.js            | 112 +++
 src/classes/EventBus/EventEmitter.ts         | 490 ++++++------
 src/classes/EventBus/index.js                |  36 +-
 src/classes/ExtensionsManager/index.js       |  66 +-
 src/classes/SplashScreenManager/index.js     |  19 +
 src/managers/ContextManager.js               |  33 +
 src/managers/CoreManager.js                  |  30 +
 src/managers/StateManager.js                 |  27 +
 src/runtime.jsx                              | 736 ++++++-------------
 src/utils/bindObjects/index.js               |  13 +
 src/utils/observeArrayInsertEmitter/index.js |  11 +
 src/utils/sortCoresByDependencies/index.js   |  22 +
 14 files changed, 835 insertions(+), 817 deletions(-)
 create mode 100644 src/classes/CoresManager/index.js
 create mode 100644 src/classes/SplashScreenManager/index.js
 create mode 100644 src/managers/ContextManager.js
 create mode 100644 src/managers/CoreManager.js
 create mode 100644 src/managers/StateManager.js
 create mode 100644 src/utils/bindObjects/index.js
 create mode 100644 src/utils/observeArrayInsertEmitter/index.js
 create mode 100644 src/utils/sortCoresByDependencies/index.js

diff --git a/.gitignore b/.gitignore
index 53fd38b..c646dba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,4 +19,5 @@
 /**/**/corenode.log
 
 # Temporal configurations
-/**/**/.aliaser
\ No newline at end of file
+/**/**/.aliaser
+.experimental
diff --git a/package.json b/package.json
index 2dfe94e..e60df89 100644
--- a/package.json
+++ b/package.json
@@ -1,31 +1,27 @@
 {
-  "name": "@ragestudio/vessel",
-  "version": "0.18.1",
-  "main": "./src/index.js",
-  "repository": "https://github.com/ragestudio/vessel.git",
-  "author": "RageStudio",
-  "license": "MIT",
-  "files": [
-    "src"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  },
-  "dependencies": {
-    "@loadable/component": "^5.16.4",
-    "@vitejs/plugin-react": "^4.3.3",
-    "comlink": "^4.4.1",
-    "history": "^5.3.0",
-    "less": "^4.2.0",
-    "million": "^3.1.11",
-    "object-observer": "^6.0.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-helmet": "^6.1.0",
-    "sucrase": "^3.35.0"
-  }
+	"name": "@ragestudio/vessel",
+	"version": "0.20.0",
+	"main": "./src/index.js",
+	"repository": "https://github.com/ragestudio/vessel.git",
+	"author": "RageStudio",
+	"license": "MIT",
+	"files": [
+		"src"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@loadable/component": "^5.16.4",
+		"@vitejs/plugin-react": "^4.3.3",
+		"comlink": "^4.4.1",
+		"history": "^5.3.0",
+		"less": "^4.2.0",
+		"million": "^3.1.11",
+		"object-observer": "^6.0.0",
+		"react": "18.3.1",
+		"react-dom": "18.3.1",
+		"react-helmet": "^6.1.0",
+		"sucrase": "^3.35.0"
+	}
 }
diff --git a/src/classes/CoresManager/index.js b/src/classes/CoresManager/index.js
new file mode 100644
index 0000000..e80eba7
--- /dev/null
+++ b/src/classes/CoresManager/index.js
@@ -0,0 +1,112 @@
+import sortCoresByDependencies from "../../utils/sortCoresByDependencies"
+
+export default class CoresManager {
+	constructor(runtime) {
+		this.runtime = runtime
+	}
+
+	cores = new Map()
+
+	context = Object()
+
+	async initialize() {
+		try {
+			const coresPaths = {
+				...import.meta.glob("/src/cores/*/*.core.jsx"),
+				...import.meta.glob("/src/cores/*/*.core.js"),
+				...import.meta.glob("/src/cores/*/*.core.ts"),
+				...import.meta.glob("/src/cores/*/*.core.tsx"),
+			}
+
+			const coresKeys = Object.keys(coresPaths)
+
+			if (coresKeys.length === 0) {
+				this.runtime.console.warn(
+					"Cannot find any cores to initialize.",
+				)
+				return true
+			}
+
+			let cores = await Promise.all(
+				coresKeys.map(async (key) => {
+					const coreModule = await coresPaths[key]().catch((err) => {
+						this.runtime.console.warn(
+							`Cannot load core [${key}]`,
+							err,
+						)
+						return false
+					})
+					return coreModule?.default ?? coreModule
+				}),
+			)
+
+			cores = cores.filter((core) => core && core.constructor)
+
+			if (!cores.length) {
+				this.console.warn(`Cannot find any valid cores to initialize.`)
+				return true
+			}
+
+			this.runtime.eventBus.emit("runtime.initialize.cores.start")
+
+			cores = sortCoresByDependencies(cores)
+
+			for (const coreClass of cores) {
+				await this.initializeCore(coreClass)
+			}
+
+			this.runtime.eventBus.emit("runtime.initialize.cores.finish")
+		} catch (error) {
+			this.runtime.eventBus.emit("runtime.initialize.cores.failed", error)
+			throw error
+		}
+	}
+
+	async initializeCore(coreClass) {
+		if (!coreClass.constructor) {
+			this.runtime.console.error(
+				`Core [${coreClass.name}] is not a valid class`,
+			)
+			return false
+		}
+
+		const namespace = coreClass.namespace ?? coreClass.name
+		this.runtime.eventBus.emit(`runtime.initialize.core.${namespace}.start`)
+
+		const coreInstance = new coreClass(this.runtime)
+
+		this.cores.set(namespace, coreInstance)
+
+		const result = await coreInstance._init()
+
+		if (!result) {
+			this.runtime.console.warn(
+				`[${namespace}] core initialized without a result`,
+			)
+		}
+
+		if (result.public_context) {
+			this.context[result.namespace] = result.public_context
+		}
+
+		this.runtime.eventBus.emit(
+			`runtime.initialize.core.${namespace}.finish`,
+		)
+		//this.states.LOADED_CORES.push(namespace)
+
+		return true
+	}
+
+	getCoreContext = () => {
+		return new Proxy(this.context, {
+			get: (target, key) => target[key],
+			set: () => {
+				throw new Error("Cannot modify the runtime property")
+			},
+		})
+	}
+
+	get = (key) => {
+		return this.cores.get(key)
+	}
+}
diff --git a/src/classes/EventBus/EventEmitter.ts b/src/classes/EventBus/EventEmitter.ts
index 7155b43..4d6b007 100644
--- a/src/classes/EventBus/EventEmitter.ts
+++ b/src/classes/EventBus/EventEmitter.ts
@@ -1,285 +1,323 @@
-import Listener from "./Listener";
+import Listener from "./Listener"
 import type {
-  EventTemplateT,
-  TemplateEventT,
-  TemplateListenerArgsT,
-  TemplateListenerContextT,
-  TemplateListenerT,
-} from "./Listener";
+	EventTemplateT,
+	TemplateEventT,
+	TemplateListenerArgsT,
+	TemplateListenerContextT,
+	TemplateListenerT,
+} from "./Listener"
 
-export default class EventEmitter<Template extends EventTemplateT = EventTemplateT> {
-  protected events: EventsT<Template> = {};
+export default class EventEmitter<
+	Template extends EventTemplateT = EventTemplateT,
+> {
+	protected events: EventsT<Template> = {}
 
-  public on = this.addListener;
+	public on = this.addListener
 
-  public off = this.removeListener;
+	public off = this.removeListener
 
-  /**
-   * Returns an array listing the events for which the emitter has registered listeners.
-   */
-  public eventNames(): TemplateEventT<Template>[] {
-    const events = this.events;
+	public id = null
 
-    return Object.keys(events).filter((event) => events[event] !== undefined);
-  }
+	/**
+	 * Returns an array listing the events for which the emitter has registered listeners.
+	 */
+	public eventNames(): TemplateEventT<Template>[] {
+		const events = this.events
 
-  /**
-   * Returns the array of listeners for the specified `event`.
-   *
-   * @param event
-   */
-  public rawListeners<Event extends TemplateEventT<Template>>(
-    event: Event,
-  ): Listener<Template, Event, this>[] {
-    const listeners = this.events[event];
+		return Object.keys(events).filter(
+			(event) => events[event] !== undefined,
+		)
+	}
 
-    if (listeners === undefined) return [];
+	/**
+	 * Returns the array of listeners for the specified `event`.
+	 *
+	 * @param event
+	 */
+	public rawListeners<Event extends TemplateEventT<Template>>(
+		event: Event,
+	): Listener<Template, Event, this>[] {
+		const listeners = this.events[event]
 
-    if (isSingleListener(listeners)) return [listeners];
+		if (listeners === undefined) return []
 
-    return listeners;
-  }
+		if (isSingleListener(listeners)) return [listeners]
 
-  /**
-   * Returns a copy of the array of listeners for the specified `event`.
-   *
-   * @param event
-   */
-  public listeners<Event extends TemplateEventT<Template>>(
-    event: Event,
-  ): TemplateListenerT<Template, Event, this>[] {
-    const listeners = this.rawListeners(event);
-    const length = listeners.length;
+		return listeners
+	}
 
-    if (length === 0) return [];
+	/**
+	 * Returns a copy of the array of listeners for the specified `event`.
+	 *
+	 * @param event
+	 */
+	public listeners<Event extends TemplateEventT<Template>>(
+		event: Event,
+	): TemplateListenerT<Template, Event, this>[] {
+		const listeners = this.rawListeners(event)
+		const length = listeners.length
 
-    const result = new Array(length);
+		if (length === 0) return []
 
-    for (let index = 0; index < length; index++) result[index] = listeners[index].fn;
+		const result = new Array(length)
 
-    return result;
-  }
+		for (let index = 0; index < length; index++)
+			result[index] = listeners[index].fn
 
-  /**
-   * Returns the number of listeners listening to the specified `event`.
-   *
-   * @param event
-   */
-  public listenerCount<Event extends TemplateEventT<Template>>(
-    event: Event,
-  ): number {
-    return this.rawListeners(event).length;
-  }
+		return result
+	}
 
-  /**
-   * Synchronously calls each of the listeners registered for the specified `event`,
-   * in the order they were registered, passing the supplied arguments to each.
-   *
-   * @param event
-   * @param args
-   * @returns - `true` if the `event` had listeners, `false` otherwise.
-   */
-  public emit<Event extends TemplateEventT<Template>>(
-    event: Event,
-    ...args: TemplateListenerArgsT<Template, Event>
-  ): boolean {
-    const events = this.events;
-    const listeners = events[event];
+	/**
+	 * Returns the number of listeners listening to the specified `event`.
+	 *
+	 * @param event
+	 */
+	public listenerCount<Event extends TemplateEventT<Template>>(
+		event: Event,
+	): number {
+		return this.rawListeners(event).length
+	}
 
-    if (listeners === undefined) {
-      if (event === "error") throw args[0];
+	/**
+	 * Synchronously calls each of the listeners registered for the specified `event`,
+	 * in the order they were registered, passing the supplied arguments to each.
+	 *
+	 * @param event
+	 * @param args
+	 * @returns - `true` if the `event` had listeners, `false` otherwise.
+	 */
+	public emit<Event extends TemplateEventT<Template>>(
+		event: Event,
+		...args: TemplateListenerArgsT<Template, Event>
+	): boolean {
+		const events = this.events
+		const listeners = events[event]
 
-      return false;
-    }
+		if (listeners === undefined) {
+			if (event === "error") throw args[0]
 
-    if (isSingleListener(listeners)) {
-      const { fn, context, once } = listeners;
+			return false
+		}
 
-      if (once) events[event] = undefined;
+		console.debug(
+			`[eventbus][${this.id}] emitted event (${event.toString()})`,
+			{
+				args: args,
+				listeners,
+			},
+		)
 
-      fn.apply(context, args);
+		if (isSingleListener(listeners)) {
+			const { fn, context, once } = listeners
 
-      return true;
-    }
+			if (once) events[event] = undefined
 
-    let length = listeners.length;
+			fn.apply(context, args)
 
-    for (let index = 0; index < length; index++) {
-      const { fn, context, once } = listeners[index];
+			return true
+		}
 
-      if (once) {
-        listeners.splice(index--, 1);
+		let length = listeners.length
 
-        length--;
-      }
+		for (let index = 0; index < length; index++) {
+			const { fn, context, once } = listeners[index]
 
-      fn.apply(context, args);
-    }
+			if (once) {
+				listeners.splice(index--, 1)
 
-    if (length === 0) events[event] = undefined;
-    else if (length === 1) events[event] = listeners[0];
+				length--
+			}
 
-    return true;
-  }
+			fn.apply(context, args)
+		}
 
-  /**
-   * Adds the `listener` function to the end of the listeners array for the specified `event`.
-   * No checks are made to see if the listener has already been added.
-   * Multiple calls passing the same combination of `event` and `listener` will result in the listener being added,
-   * and called, multiple times.
-   *
-   * @param event
-   * @param listener
-   * @param context - default: `this` (EventEmitter instance)
-   */
-  public addListener<Event extends TemplateEventT<Template>, Context = TemplateListenerContextT<Template, Event, this>>(
-    event: Event,
-    listener: TemplateListenerT<Template, Event, Context>,
-    context?: Context,
-  ): this {
-    return this._addListener(event, listener, context, true, false);
-  }
+		if (length === 0) events[event] = undefined
+		else if (length === 1) events[event] = listeners[0]
 
-  /**
-   * Adds a one-time `listener` function for the specified `event` to the end of the `listeners` array.
-   * The next time `event` is triggered, this listener is removed, and then invoked.
-   *
-   * @param event
-   * @param listener
-   * @param context - default: `this` (EventEmitter instance)
-   */
-  public once<Event extends TemplateEventT<Template>, Context = TemplateListenerContextT<Template, Event, this>>(
-    event: Event,
-    listener: TemplateListenerT<Template, Event, Context>,
-    context?: Context,
-  ): this {
-    return this._addListener(event, listener, context, true, true);
-  }
+		return true
+	}
 
-  /**
-   * Adds the `listener` function to the beginning of the listeners array for the specified `event`.
-   * No checks are made to see if the listener has already been added.
-   * Multiple calls passing the same combination of `event` and `listener` will result in the listener being added,
-   * and called, multiple times.
-   *
-   * @param event
-   * @param listener
-   * @param context - default: `this` (EventEmitter instance)
-   */
-  public prependListener<Event extends TemplateEventT<Template>, Context = TemplateListenerContextT<Template, Event, this>>(
-    event: Event,
-    listener: TemplateListenerT<Template, Event, Context>,
-    context?: Context,
-  ): this {
-    return this._addListener(event, listener, context, false, false);
-  }
+	/**
+	 * Adds the `listener` function to the end of the listeners array for the specified `event`.
+	 * No checks are made to see if the listener has already been added.
+	 * Multiple calls passing the same combination of `event` and `listener` will result in the listener being added,
+	 * and called, multiple times.
+	 *
+	 * @param event
+	 * @param listener
+	 * @param context - default: `this` (EventEmitter instance)
+	 */
+	public addListener<
+		Event extends TemplateEventT<Template>,
+		Context = TemplateListenerContextT<Template, Event, this>,
+	>(
+		event: Event,
+		listener: TemplateListenerT<Template, Event, Context>,
+		context?: Context,
+	): this {
+		return this._addListener(event, listener, context, true, false)
+	}
 
-  /**
-   * Adds a one-time `listener` function for the specified `event` to the beginning of the `listeners` array.
-   * The next time `event` is triggered, this listener is removed, and then invoked.
-   *
-   * @param event
-   * @param listener
-   * @param context - default: `this` (EventEmitter instance)
-   */
-  public prependOnceListener<Event extends TemplateEventT<Template>, Context = TemplateListenerContextT<Template, Event, this>>(
-    event: Event,
-    listener: TemplateListenerT<Template, Event, Context>,
-    context?: Context,
-  ): this {
-    return this._addListener(event, listener, context, false, true);
-  }
+	/**
+	 * Adds a one-time `listener` function for the specified `event` to the end of the `listeners` array.
+	 * The next time `event` is triggered, this listener is removed, and then invoked.
+	 *
+	 * @param event
+	 * @param listener
+	 * @param context - default: `this` (EventEmitter instance)
+	 */
+	public once<
+		Event extends TemplateEventT<Template>,
+		Context = TemplateListenerContextT<Template, Event, this>,
+	>(
+		event: Event,
+		listener: TemplateListenerT<Template, Event, Context>,
+		context?: Context,
+	): this {
+		return this._addListener(event, listener, context, true, true)
+	}
 
-  /**
-   * Removes all `listeners`, or those of the specified `event`.
-   *
-   * @param event
-   */
-  public removeAllListeners<Event extends TemplateEventT<Template>>(
-    event?: Event,
-  ): this {
-    if (event === undefined) {
-      this.events = {};
+	/**
+	 * Adds the `listener` function to the beginning of the listeners array for the specified `event`.
+	 * No checks are made to see if the listener has already been added.
+	 * Multiple calls passing the same combination of `event` and `listener` will result in the listener being added,
+	 * and called, multiple times.
+	 *
+	 * @param event
+	 * @param listener
+	 * @param context - default: `this` (EventEmitter instance)
+	 */
+	public prependListener<
+		Event extends TemplateEventT<Template>,
+		Context = TemplateListenerContextT<Template, Event, this>,
+	>(
+		event: Event,
+		listener: TemplateListenerT<Template, Event, Context>,
+		context?: Context,
+	): this {
+		return this._addListener(event, listener, context, false, false)
+	}
 
-      return this;
-    }
+	/**
+	 * Adds a one-time `listener` function for the specified `event` to the beginning of the `listeners` array.
+	 * The next time `event` is triggered, this listener is removed, and then invoked.
+	 *
+	 * @param event
+	 * @param listener
+	 * @param context - default: `this` (EventEmitter instance)
+	 */
+	public prependOnceListener<
+		Event extends TemplateEventT<Template>,
+		Context = TemplateListenerContextT<Template, Event, this>,
+	>(
+		event: Event,
+		listener: TemplateListenerT<Template, Event, Context>,
+		context?: Context,
+	): this {
+		return this._addListener(event, listener, context, false, true)
+	}
 
-    if (this.events[event] === undefined) return this;
+	/**
+	 * Removes all `listeners`, or those of the specified `event`.
+	 *
+	 * @param event
+	 */
+	public removeAllListeners<Event extends TemplateEventT<Template>>(
+		event?: Event,
+	): this {
+		if (event === undefined) {
+			this.events = {}
 
-    this.events[event] = undefined;
+			return this
+		}
 
-    return this;
-  }
+		if (this.events[event] === undefined) return this
 
-  /**
-   * Removes the specified `listener` from the `listeners` array for the specified `event`.
-   *
-   * @param event
-   * @param listener
-   */
-  public removeListener<Event extends TemplateEventT<Template>>(
-    event: Event,
-    listener: TemplateListenerT<Template, Event, this>,
-  ): this {
-    const listeners = this.events[event];
+		this.events[event] = undefined
 
-    if (listeners === undefined) return this;
+		return this
+	}
 
-    if (isSingleListener(listeners)) {
-      if (listeners.fn === listener) this.events[event] = undefined;
+	/**
+	 * Removes the specified `listener` from the `listeners` array for the specified `event`.
+	 *
+	 * @param event
+	 * @param listener
+	 */
+	public removeListener<Event extends TemplateEventT<Template>>(
+		event: Event,
+		listener: TemplateListenerT<Template, Event, this>,
+	): this {
+		const listeners = this.events[event]
 
-      return this;
-    }
+		if (listeners === undefined) return this
 
-    for (let index = listeners.length - 1; index >= 0; index--) {
-      if (listeners[index].fn === listener) listeners.splice(index, 1);
-    }
+		if (isSingleListener(listeners)) {
+			if (listeners.fn === listener) this.events[event] = undefined
 
-    if (listeners.length === 0) this.events[event] = undefined;
-    else if (listeners.length === 1) this.events[event] = listeners[0];
+			return this
+		}
 
-    return this;
-  }
+		for (let index = listeners.length - 1; index >= 0; index--) {
+			if (listeners[index].fn === listener) listeners.splice(index, 1)
+		}
 
-  protected _addListener<Event extends TemplateEventT<Template>, Context = TemplateListenerContextT<Template, Event, this>>(
-    event: Event,
-    fn: TemplateListenerT<Template, Event, Context>,
-    context: Context = this as never,
-    append: boolean,
-    once: boolean,
-  ): this {
-    const events = this.events;
-    const listeners = events[event];
-    const listener = new Listener<Template, Event, Context>(fn, context, once);
+		if (listeners.length === 0) this.events[event] = undefined
+		else if (listeners.length === 1) this.events[event] = listeners[0]
 
-    if (listeners === undefined) {
-      events[event] = listener;
+		return this
+	}
 
-      return this;
-    }
+	protected _addListener<
+		Event extends TemplateEventT<Template>,
+		Context = TemplateListenerContextT<Template, Event, this>,
+	>(
+		event: Event,
+		fn: TemplateListenerT<Template, Event, Context>,
+		context: Context = this as never,
+		append: boolean,
+		once: boolean,
+	): this {
+		const events = this.events
+		const listeners = events[event]
+		const listener = new Listener<Template, Event, Context>(
+			fn,
+			context,
+			once,
+		)
 
-    if (isSingleListener(listeners)) {
-      events[event] = append ? [listeners, listener] : [listener, listeners];
+		if (listeners === undefined) {
+			events[event] = listener
 
-      return this;
-    }
+			return this
+		}
 
-    if (append) {
-      listeners.push(listener);
-    } else {
-      listeners.unshift(listener);
-    }
+		if (isSingleListener(listeners)) {
+			events[event] = append
+				? [listeners, listener]
+				: [listener, listeners]
 
-    return this;
-  }
+			return this
+		}
+
+		if (append) {
+			listeners.push(listener)
+		} else {
+			listeners.unshift(listener)
+		}
+
+		return this
+	}
 }
 
 function isSingleListener<Type>(value: Type | Type[]): value is Type {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (value as any).length === undefined;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return (value as any).length === undefined
 }
 
 export type EventsT<Template extends EventTemplateT> = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [Event in TemplateEventT<Template>]?: Listener<Template, Event, any> | Listener<Template, Event, any>[];
-};
\ No newline at end of file
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	[Event in TemplateEventT<Template>]?:
+		| Listener<Template, Event, any>
+		| Listener<Template, Event, any>[]
+}
diff --git a/src/classes/EventBus/index.js b/src/classes/EventBus/index.js
index f64eeb4..2bd0c2b 100644
--- a/src/classes/EventBus/index.js
+++ b/src/classes/EventBus/index.js
@@ -1,27 +1,27 @@
 import EventEmitter from "./EventEmitter"
 
 export default class EventBus extends EventEmitter {
-    constructor(params = {}) {
-        super({ ...params, captureRejections: true })
+	constructor(params = {}) {
+		super({ ...params, captureRejections: true })
 
-        this.id = params?.id
-    }
+		this.id = params?.id
+	}
 
-    _emit = this.emit
+	_emit = this.emit
 
-    emit = (event, ...args) => {
-        return this._emit(event, ...args)
-    }
+	emit = (event, ...args) => {
+		return this._emit(event, ...args)
+	}
 
-    on = (event, listener, context) => {
-        return this._addListener(event, listener, context, true, false)
-    }
+	on = (event, listener, context) => {
+		return this._addListener(event, listener, context, true, false)
+	}
 
-    off = (event, listener) => {
-        return this.removeListener(event, listener)
-    }
+	off = (event, listener) => {
+		return this.removeListener(event, listener)
+	}
 
-    once = (event, listener, context) => {
-        return this.once(event, listener, context)
-    }
-}
\ No newline at end of file
+	once = (event, listener, context) => {
+		return this.once(event, listener, context)
+	}
+}
diff --git a/src/classes/ExtensionsManager/index.js b/src/classes/ExtensionsManager/index.js
index 2e83407..8796f13 100644
--- a/src/classes/ExtensionsManager/index.js
+++ b/src/classes/ExtensionsManager/index.js
@@ -5,46 +5,46 @@ import * as Comlink from "comlink"
 import ExtensionWorker from "../../workers/extension.js?worker"
 
 export default class ExtensionManager {
-    logger = new InternalConsole({
-        namespace: "ExtensionsManager",
-        bgColor: "bgMagenta",
-    })
+	logger = new InternalConsole({
+		namespace: "ExtensionsManager",
+		bgColor: "bgMagenta",
+	})
 
-    extensions = new Map()
+	extensions = new Map()
 
-    loadExtension = async (manifest) => {
-        if (isUrl(manifest)) {
-            manifest = await fetch(manifest)
-            manifest = await manifest.json()
-        }
+	loadExtension = async (manifest) => {
+		throw new Error("Not implemented")
 
-        const worker = new ExtensionWorker()
+		if (isUrl(manifest)) {
+			manifest = await fetch(manifest)
+			manifest = await manifest.json()
+		}
 
-        worker.postMessage({
-            event: "load",
-            manifest: manifest,
-        })
+		const worker = new ExtensionWorker()
 
-        await new Promise((resolve) => {
-            worker.onmessage = ({data}) => {
-                if (data.event === "loaded") {
-                    resolve()
-                }
-            }
-        })
+		worker.postMessage({
+			event: "load",
+			manifest: manifest,
+		})
 
-        console.log(Comlink.wrap(worker))
+		await new Promise((resolve) => {
+			worker.onmessage = ({ data }) => {
+				if (data.event === "loaded") {
+					resolve()
+				}
+			}
+		})
 
-        // if (typeof main.events === "object") {
-        //     Object.entries(main.events).forEach(([event, handler]) => {
-        //         main.event.on(event, handler)
-        //     })
-        // }
+		console.log(Comlink.wrap(worker))
 
-        // this.extensions.set(manifest.registryId,main.public)
-    }
+		// if (typeof main.events === "object") {
+		//     Object.entries(main.events).forEach(([event, handler]) => {
+		//         main.event.on(event, handler)
+		//     })
+		// }
 
-    installExtension = async () => {
+		// this.extensions.set(manifest.registryId,main.public)
+	}
 
-    }
-}
\ No newline at end of file
+	installExtension = async () => {}
+}
diff --git a/src/classes/SplashScreenManager/index.js b/src/classes/SplashScreenManager/index.js
new file mode 100644
index 0000000..aac2ee5
--- /dev/null
+++ b/src/classes/SplashScreenManager/index.js
@@ -0,0 +1,19 @@
+export default class SplashScreenManager {
+	constructor(containerId = "splash-screen") {
+		this.containerId = containerId
+	}
+
+	attach() {
+		const container = document.getElementById(this.containerId)
+		if (container && !container.classList.contains("app_splash_visible")) {
+			container.classList.add("app_splash_visible")
+		}
+	}
+
+	detach() {
+		const container = document.getElementById(this.containerId)
+		if (container && container.classList.contains("app_splash_visible")) {
+			container.classList.remove("app_splash_visible")
+		}
+	}
+}
diff --git a/src/managers/ContextManager.js b/src/managers/ContextManager.js
new file mode 100644
index 0000000..8021cfb
--- /dev/null
+++ b/src/managers/ContextManager.js
@@ -0,0 +1,33 @@
+export default class ContextManager {
+	constructor(runtime) {
+		this.runtime = runtime
+		this.context = {}
+		this.proxy = this.createSecureProxy()
+	}
+
+	createSecureProxy() {
+		return new Proxy(this.context, {
+			get: (target, prop) => target[prop],
+			set: () => {
+				throw new Error("Direct context modification not allowed")
+			},
+			defineProperty: () => false,
+		})
+	}
+
+	registerConstant(key, value) {
+		Object.defineProperty(this.context, key, {
+			value,
+			writable: false,
+			configurable: false,
+		})
+	}
+
+	registerService(key, factory) {
+		Object.defineProperty(this.context, key, {
+			get: factory,
+			configurable: false,
+			enumerable: true,
+		})
+	}
+}
diff --git a/src/managers/CoreManager.js b/src/managers/CoreManager.js
new file mode 100644
index 0000000..fb040ba
--- /dev/null
+++ b/src/managers/CoreManager.js
@@ -0,0 +1,30 @@
+export default class CoreManager {
+	constructor(runtime) {
+		this.runtime = runtime
+		this.cores = new Map()
+	}
+
+	async initializeCores() {
+		const coreModules = await this.discoverCoreModules()
+		const sortedCores = DependencyResolver.resolveDependencies(coreModules)
+
+		for (const CoreClass of sortedCores) {
+			try {
+				const coreInstance = new CoreClass(this.runtime)
+				await coreInstance.initialize()
+				this.registerCore(CoreClass, coreInstance)
+			} catch (error) {
+				this.runtime.console.error(
+					`Core ${CoreClass.name} failed:`,
+					error,
+				)
+				throw error
+			}
+		}
+	}
+
+	registerCore(CoreClass, instance) {
+		this.cores.set(CoreClass.name, instance)
+		this.runtime.contextManager.registerCore(CoreClass.name, instance)
+	}
+}
diff --git a/src/managers/StateManager.js b/src/managers/StateManager.js
new file mode 100644
index 0000000..512d508
--- /dev/null
+++ b/src/managers/StateManager.js
@@ -0,0 +1,27 @@
+import { Observable } from "object-observer"
+
+export default class StateManager {
+	constructor(runtime) {
+		this.runtime = runtime
+		this.states = Observable.from({
+			status: "booting",
+			loadedCores: [],
+			activePlugins: [],
+			errors: [],
+		})
+	}
+
+	transitionTo(newState, payload) {
+		const validTransitions = {
+			booting: ["initializing", "crashed"],
+			initializing: ["ready", "crashed"],
+			ready: ["suspend", "crashed"],
+			crashed: [],
+		}
+
+		if (validTransitions[this.states.status].includes(newState)) {
+			this.states.status = newState
+			this.runtime.eventBus.emit(`runtime.state.${newState}`, payload)
+		}
+	}
+}
diff --git a/src/runtime.jsx b/src/runtime.jsx
index 1afc869..6239cb6 100644
--- a/src/runtime.jsx
+++ b/src/runtime.jsx
@@ -1,526 +1,242 @@
 import pkgJson from "../package.json"
 
 import React from "react"
-import ReactDOM from "react-dom"
 import { createRoot } from "react-dom/client"
 
 import { createBrowserHistory } from "history"
 import { Observable } from "object-observer"
 
-import Extension from "./extension"
-
+import CoresManager from "./classes/CoresManager"
+import ExtensionManager from "./classes/ExtensionsManager"
 import EventBus from "./classes/EventBus"
 import InternalConsole from "./classes/InternalConsole"
-import ExtensionManager from "./classes/ExtensionsManager"
+import SplashScreenManager from "./classes/SplashScreenManager"
 
+import bindObjects from "./utils/bindObjects"
 import isMobile from "./utils/isMobile"
 
 import * as StaticRenders from "./internals/renders"
 import "./internals/style/index.css"
 
-export default class EviteRuntime {
-    Flags = window.flags = Observable.from({
-        debug: false,
-    })
-
-    INTERNAL_CONSOLE = new InternalConsole({
-        namespace: "Runtime",
-        bgColor: "bgMagenta",
-    })
-
-    EXTENSIONS = Object()
-    CORES = Object()
-
-    PublicContext = window.app = Object()
-
-    ExtensionsPublicContext = Object()
-    CoresPublicContext = Object()
-
-    STATES = Observable.from({
-        LOAD_STATE: "early",
-
-        INITIALIZER_TASKS: [],
-
-        LOADED_CORES: [],
-
-        ATTACHED_EXTENSIONS: [],
-        REJECTED_EXTENSIONS: [],
-
-        INITIALIZATION_START: null,
-        INITIALIZATION_STOP: null,
-        INITIALIZATION_TOOKS: null,
-    })
-
-    APP_RENDERER = null
-    SPLASH_RENDERER = null
-
-    constructor(
-        App,
-        Params = {
-            renderMount: "root",
-        }
-    ) {
-        this.INTERNAL_CONSOLE.log(`Using React ${React.version}`)
-
-        this.AppComponent = App
-        this.Params = Params
-
-        // toogle splash
-        this.attachSplashScreen()
-
-        // controllers
-        this.root = createRoot(document.getElementById(this.Params.renderMount ?? "root"))
-        this.history = this.registerPublicMethod({ key: "history", locked: true }, createBrowserHistory())
-        this.eventBus = this.registerPublicMethod({ key: "eventBus", locked: true }, new EventBus())
-
-        window.app.cores = new Proxy(this.CoresPublicContext, {
-            get: (target, key) => {
-                return target[key]
-            },
-            set: (target, key, value) => {
-                throw new Error("You can't set a core value")
-            }
-        })
-
-        window.app.extensions = new ExtensionManager()
-
-        this.registerPublicMethod({ key: "isMobile", locked: true }, isMobile())
-        this.registerPublicMethod({ key: "__version", locked: true }, pkgJson.version)
-
-        if (typeof this.AppComponent.splashAwaitEvent === "string") {
-            this.eventBus.on(this.AppComponent.splashAwaitEvent, () => {
-                this.detachSplashScreen()
-            })
-        }
-
-        for (const [key, fn] of Object.entries(this.internalEvents)) {
-            this.eventBus.on(key, fn)
-        }
-
-        // emit attached extensions change events
-        Observable.observe(this.STATES.ATTACHED_EXTENSIONS, (changes) => {
-            changes.forEach((change) => {
-                if (change.type === "insert") {
-                    this.eventBus.emit(`runtime.extension.attached`, change)
-                }
-            })
-        })
-
-        // emit rejected extensions change events
-        Observable.observe(this.STATES.REJECTED_EXTENSIONS, (changes) => {
-            changes.forEach((change) => {
-                if (change.type === "insert") {
-                    this.eventBus.emit(`runtime.extension.rejected`, change)
-                }
-            })
-        })
-
-        return this.initialize().catch((error) => {
-            this.eventBus.emit("runtime.initialize.crash", error)
-        })
-    }
-
-    internalEvents = {
-        "runtime.initialize.start": () => {
-            this.STATES.LOAD_STATE = "initializing"
-            this.STATES.INITIALIZATION_START = performance.now()
-        },
-        "runtime.initialize.finish": () => {
-            const time = performance.now()
-
-            this.STATES.INITIALIZATION_STOP = time
-
-            if (this.STATES.INITIALIZATION_START) {
-                this.STATES.INITIALIZATION_TOOKS = time - this.STATES.INITIALIZATION_START
-            }
-
-            this.STATES.LOAD_STATE = "initialized"
-        },
-        "runtime.initialize.crash": (error) => {
-            this.STATES.LOAD_STATE = "crashed"
-
-            if (this.SPLASH_RENDERER) {
-                this.detachSplashScreen()
-            }
-
-            this.INTERNAL_CONSOLE.error("Runtime crashed on initialization \n", error)
-
-            // render crash
-            this.render(this.AppComponent.staticRenders?.Crash ?? StaticRenders.Crash, {
-                crash: {
-                    message: "Runtime crashed on initialization",
-                    details: error.toString(),
-                }
-            })
-        },
-        "runtime.crash": (crash) => {
-            this.STATES.LOAD_STATE = "crashed"
-
-            if (this.SPLASH_RENDERER) {
-                this.detachSplashScreen()
-            }
-
-            // render crash
-            this.render(this.AppComponent.staticRenders?.Crash ?? StaticRenders.Crash, {
-                crash
-            })
-        },
-    }
-
-    bindObjects = async (bind, events, parent) => {
-        let boundEvents = {}
-
-        for await (let [event, handler] of Object.entries(events)) {
-            if (typeof handler === "object") {
-                boundEvents[event] = await this.bindObjects(bind, handler, parent)
-            }
-
-            if (typeof handler === "function") {
-                boundEvents[event] = handler.bind(bind)
-            }
-        }
-
-        return boundEvents
-    }
-
-    async initialize() {
-        this.eventBus.emit("runtime.initialize.start")
-
-        await this.initializeCores()
-
-        await this.performInitializerTasks()
-
-        // call early app initializer 
-        if (typeof this.AppComponent.initialize === "function") {
-            await this.AppComponent.initialize.apply(this)
-        }
-
-        // handle app events handlers registration
-        if (typeof this.AppComponent.publicEvents === "object") {
-            for await (let [event, handler] of Object.entries(this.AppComponent.publicEvents)) {
-                this.eventBus.on(event, handler.bind(this))
-            }
-        }
-
-        // handle app public methods registration
-        if (typeof this.AppComponent.publicMethods === "object") {
-            await this.registerPublicMethods(this.AppComponent.publicMethods)
-        }
-
-        // emit initialize finish event
-        this.eventBus.emit("runtime.initialize.finish")
-
-        this.render()
-
-        if (!this.AppComponent.splashAwaitEvent) {
-            this.detachSplashScreen()
-        }
-    }
-
-    initializeCore = async (core) => {
-        if (!core.constructor) {
-            this.INTERNAL_CONSOLE.error(`Core [${core.name}] is not a class`)
-
-            return false
-        }
-
-        const namespace = core.namespace ?? core.name
-
-        this.eventBus.emit(`runtime.initialize.core.${namespace}.start`)
-
-        // construct class
-        let coreInstance = new core(this)
-
-        // set core to context
-        this.CORES[namespace] = coreInstance
-
-        const initializationResult = await coreInstance._init()
-
-        if (!initializationResult) {
-            this.INTERNAL_CONSOLE.warn(`[${namespace}] initializes without returning a result.`)
-        }
-
-        if (initializationResult.public_context) {
-            this.CoresPublicContext[initializationResult.namespace] = initializationResult.public_context
-        }
-
-        // emit event
-        this.eventBus.emit(`runtime.initialize.core.${namespace}.finish`)
-
-        // register internal core
-        this.STATES.LOADED_CORES.push(namespace)
-
-        return true
-    }
-
-    initializeCores = async () => {
-        try {
-            const coresPaths = {
-                ...import.meta.glob("/src/cores/*/*.core.jsx"),
-                ...import.meta.glob("/src/cores/*/*.core.js"),
-                ...import.meta.glob("/src/cores/*/*.core.ts"),
-                ...import.meta.glob("/src/cores/*/*.core.tsx"),
-            }
-
-            const coresKeys = Object.keys(coresPaths)
-
-            if (coresKeys.length === 0) {
-                this.INTERNAL_CONSOLE.warn(`Skipping cores initialization. No cores found.`)
-
-                return true
-            }
-
-            // import all cores
-            let cores = await Promise.all(coresKeys.map(async (key) => {
-                const core = await coresPaths[key]().catch((err) => {
-                    this.INTERNAL_CONSOLE.warn(`Cannot load core from ${key}.`, err)
-                    return false
-                })
-
-                return core.default ?? core
-            }))
-
-            cores = cores.filter((core) => {
-                return core.constructor
-            })
-
-            if (!cores) {
-                this.INTERNAL_CONSOLE.warn(`Skipping cores initialization. No valid cores found.`)
-
-                return true
-            }
-
-            this.eventBus.emit(`runtime.initialize.cores.start`)
-
-            if (!Array.isArray(cores)) {
-                this.INTERNAL_CONSOLE.error(`Cannot initialize cores, cause it is not an array. Core dependency is not supported yet. You must use an array to define your core load queue.`)
-                return
-            }
-
-            // sort cores by dependencies
-            cores.forEach((core) => {
-                if (core.dependencies) {
-                    core.dependencies.forEach((dependency) => {
-                        // find dependency
-                        const dependencyIndex = cores.findIndex((_core) => {
-                            return (_core.namespace ?? _core.name) === dependency
-                        })
-
-                        if (dependencyIndex === -1) {
-                            this.INTERNAL_CONSOLE.error(`Cannot find dependency [${dependency}] for core [${core.name}]`)
-                            return
-                        }
-
-                        // move dependency to top
-                        cores.splice(0, 0, cores.splice(dependencyIndex, 1)[0])
-                    })
-                }
-            })
-
-            for await (let coreClass of cores) {
-                await this.initializeCore(coreClass)
-            }
-
-            // emit event
-            this.eventBus.emit(`runtime.initialize.cores.finish`)
-        } catch (error) {
-            this.eventBus.emit(`runtime.initialize.cores.failed`, error)
-
-            // make sure to throw that, app must crash if core fails to load
-            throw error
-        }
-    }
-
-    appendToInitializer = (task) => {
-        let tasks = []
-
-        if (Array.isArray(task)) {
-            tasks = task
-        } else {
-            tasks.push(task)
-        }
-
-        tasks.forEach((_task) => {
-            if (typeof _task === "function") {
-                this.STATES.INITIALIZER_TASKS.push(_task)
-            }
-        })
-    }
-
-    performInitializerTasks = async () => {
-        if (this.STATES.INITIALIZER_TASKS.length === 0) {
-            this.INTERNAL_CONSOLE.warn("No initializer tasks found, skipping...")
-            return true
-        }
-
-        for await (let task of this.STATES.INITIALIZER_TASKS) {
-            if (typeof task === "function") {
-                try {
-                    await task(this)
-                } catch (error) {
-                    this.INTERNAL_CONSOLE.error(`Failed to perform initializer task >`, error)
-                }
-            }
-        }
-    }
-
-    // CONTEXT CONTROL
-    registerPublicMethods = async (methods) => {
-        if (typeof methods !== "object") {
-            this.INTERNAL_CONSOLE.error("Methods must be an object")
-            return false
-        }
-
-        const boundedPublicMethods = await this.bindObjects(this, methods)
-
-        for await (let [methodName, fn] of Object.entries(boundedPublicMethods)) {
-            this.registerPublicMethod({
-                key: methodName,
-                locked: true,
-            }, fn)
-        }
-    }
-
-    registerPublicMethod = (params = {}, value, ...args) => {
-        let opts = {
-            key: params.key,
-            locked: params.locked ?? false,
-            enumerable: params.enumerable ?? true,
-        }
-
-        if (typeof params === "string") {
-            opts.key = params
-        }
-
-        if (typeof opts.key === "undefined") {
-            throw new Error("key is required")
-        }
-
-        if (args.length > 0) {
-            value = value(...args)
-        }
-
-        try {
-            Object.defineProperty(this.PublicContext, opts.key, {
-                value,
-                enumerable: opts.enumerable,
-                configurable: opts.locked
-            })
-        } catch (error) {
-            this.INTERNAL_CONSOLE.error(error)
-        }
-
-        return this.PublicContext[opts.key]
-    }
-
-    // EXTENSIONS CONTROL
-    initializeExtension = (extension) => {
-        return new Promise(async (resolve, reject) => {
-            if (typeof extension !== "function") {
-                return reject({
-                    reason: "EXTENSION_NOT_VALID_CLASS",
-                })
-            }
-
-            extension = new extension(this.ExtensionsContext.getProxy(), this)
-
-            const extensionName = extension.refName ?? extension.constructor.name
-
-            if (extension instanceof Extension) {
-                // good for u
-            } else {
-                this.STATES.REJECTED_EXTENSIONS = [extensionName, ...this.STATES.REJECTED_EXTENSIONS]
-
-                return reject({
-                    name: extensionName,
-                    reason: "EXTENSION_NOT_VALID_INSTANCE",
-                })
-            }
-
-            // await to extension initializer
-            await extension.__initializer()
-
-            // appends initializers
-            if (typeof extension.initializers !== "undefined") {
-                for await (let initializer of extension.initializers) {
-                    await initializer.apply(this.ExtensionsContext.getProxy(), initializer)
-                }
-            }
-
-            // set window context
-            if (typeof extension.publicMethods === "object") {
-                Object.keys(extension.publicMethods).forEach((key) => {
-                    if (typeof extension.publicMethods[key] === "function") {
-                        extension.publicMethods[key].bind(this.ExtensionsContext.getProxy())
-                    }
-
-                    this.registerPublicMethod({ key }, extension.publicMethods[key])
-                })
-            }
-
-            // update attached extensions
-            this.STATES.ATTACHED_EXTENSIONS.push(extensionName)
-
-            // set extension context
-            this.EXTENSIONS[extensionName] = extension
-
-            return resolve()
-        })
-    }
-
-    attachSplashScreen = () => {
-        // create a new div inside the container
-        let elementContainer = document.getElementById("splash-screen")
-
-        if (!elementContainer) {
-            elementContainer = document.createElement("div")
-
-            // set the id of the new div
-            elementContainer.id = "splash-screen"
-
-            document.body.appendChild(elementContainer)
-        }
-
-        if (this.AppComponent.staticRenders?.Initialization) {
-            this.SPLASH_RENDERER = ReactDOM.render(React.createElement((this.AppComponent.staticRenders?.Initialization), {
-                states: this.STATES,
-            }), elementContainer)
-        }
-    }
-
-    detachSplashScreen = async () => {
-        const container = document.getElementById("splash-screen")
-
-        if (container) {
-            if (this.SPLASH_RENDERER && typeof this.SPLASH_RENDERER.onUnmount) {
-                await this.SPLASH_RENDERER.onUnmount()
-            }
-
-            ReactDOM.unmountComponentAtNode(container)
-            container.remove()
-
-            this.SPLASH_RENDERER = null
-        }
-    }
-
-    // RENDER METHOD
-    render(component = this.AppComponent, props = {}) {
-        this.APP_RENDERER = React.createElement(
-            component,
-            {
-                runtime: new Proxy(this, {
-                    get: (target, prop) => {
-                        return target[prop]
-                    },
-                    set: (target, prop, value) => {
-                        throw new Error("Cannot set property of runtime")
-                    }
-                }),
-                cores: this.CORES,
-                ...props,
-            }
-        )
-
-        this.root.render(this.APP_RENDERER)
-    }
-}
\ No newline at end of file
+export default class Runtime {
+	constructor(baseAppClass, params = { renderMount: "root" }) {
+		this.baseAppClass = baseAppClass
+		this.params = params
+
+		this.initialize().catch((error) => {
+			this.eventBus.emit("runtime.initialize.crash", error)
+		})
+	}
+
+	// contexts & managers
+	publicContext = (window.app = {})
+	cores = new CoresManager(this)
+	extensions = new ExtensionManager(this)
+	splash = new SplashScreenManager()
+
+	flags = Observable.from({
+		debug: false,
+	})
+	console = new InternalConsole({
+		namespace: "Runtime",
+		bgColor: "bgMagenta",
+	})
+	history = createBrowserHistory()
+	eventBus = new EventBus({
+		id: "runtime",
+	})
+
+	states = Observable.from({
+		LOAD_STATE: "early",
+		INITIALIZER_TASKS: [],
+		INITIALIZATION_START: null,
+		INITIALIZATION_STOP: null,
+		INITIALIZATION_TOOKS: null,
+	})
+
+	internalEvents = {
+		"runtime.initialize.start": () => {
+			this.states.LOAD_STATE = "initializing"
+			this.states.INITIALIZATION_START = performance.now()
+		},
+		"runtime.initialize.finish": () => {
+			const time = performance.now()
+			this.states.INITIALIZATION_STOP = time
+			if (this.states.INITIALIZATION_START) {
+				this.states.INITIALIZATION_TOOKS =
+					time - this.states.INITIALIZATION_START
+			}
+			this.states.LOAD_STATE = "initialized"
+		},
+		"runtime.initialize.crash": (error) => {
+			this.states.LOAD_STATE = "crashed"
+			this.splash.detach()
+			this.console.error("Runtime crashed on initialization\n", error)
+			this.render(
+				this.baseAppClass.staticRenders?.Crash ?? StaticRenders.Crash,
+				{
+					crash: {
+						message: "Runtime crashed on initialization",
+						details: error.toString(),
+					},
+				},
+			)
+		},
+		"runtime.crash": (crash) => {
+			this.states.LOAD_STATE = "crashed"
+			this.splash.detach()
+			this.render(
+				this.baseAppClass.staticRenders?.Crash ?? StaticRenders.Crash,
+				{ crash },
+			)
+		},
+	}
+
+	registerEventsToBus(eventsObj) {
+		for (const [event, handler] of Object.entries(eventsObj)) {
+			this.eventBus.on(event, handler.bind(this))
+		}
+	}
+
+	async initialize() {
+		this.eventBus.emit("runtime.initialize.start")
+
+		this.console.log(
+			`Using React ${React.version} | Runtime v${pkgJson.version}`,
+		)
+
+		this.splash.attach()
+
+		this.root = createRoot(
+			document.getElementById(this.params.renderMount ?? "root"),
+		)
+
+		this.registerPublicField("history", this.history)
+		this.registerPublicField("eventBus", this.eventBus)
+		this.registerPublicField("isMobile", isMobile())
+		this.registerPublicField("__version", pkgJson.version)
+
+		window.app.cores = this.cores.getCoreContext()
+		//window.app.extensions = new ExtensionManager()
+
+		this.registerEventsToBus(this.internalEvents)
+
+		if (typeof this.baseAppClass.events === "object") {
+			for (const [event, handler] of Object.entries(
+				this.baseAppClass.events,
+			)) {
+				this.eventBus.on(event, (...args) => handler(this, ...args))
+			}
+		}
+
+		if (this.baseAppClass.splashAwaitEvent) {
+			this.eventBus.on(this.baseAppClass.splashAwaitEvent, () => {
+				this.splash.detach()
+			})
+		}
+
+		await this.cores.initialize()
+		await this.performInitializerTasks()
+
+		if (typeof this.baseAppClass.initialize === "function") {
+			await this.baseAppClass.initialize.call(this)
+		}
+
+		if (typeof this.baseAppClass.publicEvents === "object") {
+			for (const [event, handler] of Object.entries(
+				this.baseAppClass.publicEvents,
+			)) {
+				this.eventBus.on(event, handler.bind(this))
+			}
+		}
+
+		if (typeof this.baseAppClass.publicMethods === "object") {
+			const boundedPublicMethods = await bindObjects(
+				this,
+				this.baseAppClass.publicMethods,
+			)
+
+			for (const [methodName, fn] of Object.entries(
+				boundedPublicMethods,
+			)) {
+				this.registerPublicField({ key: methodName, locked: true }, fn)
+			}
+		}
+
+		this.eventBus.emit("runtime.initialize.finish")
+		this.render(this.baseAppClass)
+
+		if (!this.baseAppClass.splashAwaitEvent) {
+			this.splash.detach()
+		}
+	}
+
+	appendToInitializer(task) {
+		let tasks = Array.isArray(task) ? task : [task]
+		tasks.forEach((_task) => {
+			if (typeof _task === "function") {
+				this.states.INITIALIZER_TASKS.push(_task)
+			}
+		})
+	}
+
+	async performInitializerTasks() {
+		if (this.states.INITIALIZER_TASKS.length === 0) {
+			this.console.warn("Cannot find any initializer tasks, skipping...")
+			return true
+		}
+
+		for (const task of this.states.INITIALIZER_TASKS) {
+			if (typeof task === "function") {
+				try {
+					await task(this)
+				} catch (error) {
+					this.console.error("Error in initializer task:", error)
+				}
+			}
+		}
+	}
+
+	registerPublicField = (params = {}, value, ...args) => {
+		const opts = {
+			key: typeof params === "string" ? params : params.key,
+			locked: params.locked ?? false,
+			enumerable: params.enumerable ?? true,
+		}
+		if (typeof opts.key === "undefined") {
+			throw new Error("a key is required")
+		}
+		if (args.length > 0) {
+			value = value(...args)
+		}
+		try {
+			Object.defineProperty(this.publicContext, opts.key, {
+				value,
+				enumerable: opts.enumerable,
+				configurable: opts.locked,
+			})
+		} catch (error) {
+			this.console.error(error)
+		}
+		return this.publicContext[opts.key]
+	}
+
+	render(component, props = {}) {
+		const renderer = React.createElement(component, {
+			runtime: this,
+			...props,
+		})
+
+		this.root.render(renderer)
+	}
+
+	getRuntimeStatus() {
+		return {
+			state: this.states.LOAD_STATE,
+			initializationDuration: this.states.INITIALIZATION_TOOKS,
+			loadedCores: this.states.LOADED_CORES,
+			attachedExtensions: this.states.ATTACHED_EXTENSIONS,
+			rejectedExtensions: this.states.REJECTED_EXTENSIONS,
+		}
+	}
+}
diff --git a/src/utils/bindObjects/index.js b/src/utils/bindObjects/index.js
new file mode 100644
index 0000000..75d3ed3
--- /dev/null
+++ b/src/utils/bindObjects/index.js
@@ -0,0 +1,13 @@
+export default function bindObjects(bind, events) {
+	let boundEvents = {}
+
+	for (const [event, handler] of Object.entries(events)) {
+		if (typeof handler === "object") {
+			boundEvents[event] = bindObjects(bind, handler)
+		} else if (typeof handler === "function") {
+			boundEvents[event] = handler.bind(bind)
+		}
+	}
+
+	return boundEvents
+}
diff --git a/src/utils/observeArrayInsertEmitter/index.js b/src/utils/observeArrayInsertEmitter/index.js
new file mode 100644
index 0000000..0f2068f
--- /dev/null
+++ b/src/utils/observeArrayInsertEmitter/index.js
@@ -0,0 +1,11 @@
+import { Observable } from "object-observer"
+
+export default (observableArray, eventBus, eventName) => {
+	Observable.observe(observableArray, (changes) => {
+		changes.forEach((change) => {
+			if (change.type === "insert") {
+				eventBus.emit(eventName, change)
+			}
+		})
+	})
+}
diff --git a/src/utils/sortCoresByDependencies/index.js b/src/utils/sortCoresByDependencies/index.js
new file mode 100644
index 0000000..93577ce
--- /dev/null
+++ b/src/utils/sortCoresByDependencies/index.js
@@ -0,0 +1,22 @@
+export default (cores) => {
+	cores.forEach((core) => {
+		if (core.dependencies) {
+			core.dependencies.forEach((dependency) => {
+				const depIndex = cores.findIndex((_core) => {
+					return (_core.namespace ?? _core.name) === dependency
+				})
+				if (depIndex === -1) {
+					console.error(
+						`Cannot find dependency [${dependency}] for core [${core.name}]`,
+					)
+					return
+				}
+				if (depIndex !== 0) {
+					cores.unshift(cores.splice(depIndex, 1)[0])
+				}
+			})
+		}
+	})
+
+	return cores
+}