@kithinji/orca 1.0.26 → 1.0.29

package/dist/browser/index.iife.js

@@ -14,11 +14,11 @@ var kithinjiorca = (() => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __copyProps = (to, from2, except, desc) => {
-    if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-      for (let key of __getOwnPropNames(from2))
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
         if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
     return to;
   };
@@ -31,7 +31,6 @@ var kithinjiorca = (() => {
     ActorModule: () => ActorModule,
     BOOTSTRAP: () => BOOTSTRAP,
     BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
-    BehaviorSubject: () => BehaviorSubject,
     Body: () => Body,
     BrowserFactory: () => BrowserFactory,
     COMPONENT: () => COMPONENT,
@@ -51,6 +50,7 @@ var kithinjiorca = (() => {
     EXPORTS_KEY: () => EXPORTS_KEY,
     EXPRESS_ADAPTER_HOST: () => EXPRESS_ADAPTER_HOST,
     Fragment: () => Fragment,
+    GUARDS_KEY: () => GUARDS_KEY,
     Get: () => Get,
     HTTP_METHOD_KEY: () => HTTP_METHOD_KEY,
     HandlerParamType: () => HandlerParamType,
@@ -60,6 +60,7 @@ var kithinjiorca = (() => {
     IMPORTS_KEY: () => IMPORTS_KEY,
     INJECTABLE: () => INJECTABLE,
     INJECT_TOKENS_KEY: () => INJECT_TOKENS_KEY,
+    INTERCEPTORS_KEY: () => INTERCEPTORS_KEY,
     Inject: () => Inject,
     Injectable: () => Injectable,
     Injector: () => Injector,
@@ -71,7 +72,6 @@ var kithinjiorca = (() => {
     ORCA_ELEMENT_TYPE: () => ORCA_ELEMENT_TYPE,
     ORCA_FRAGMENT_TYPE: () => ORCA_FRAGMENT_TYPE,
     OSC: () => OSC,
-    Observable: () => Observable,
     OrcaComponent: () => OrcaComponent,
     PARAMS_META_KEY: () => PARAMS_META_KEY,
     PATH_KEY: () => PATH_KEY,
@@ -81,60 +81,51 @@ var kithinjiorca = (() => {
     Post: () => Post,
     ProviderNormalizer: () => ProviderNormalizer,
     Query: () => Query,
+    REQUEST_CONTEXT: () => REQUEST_CONTEXT,
+    Req: () => Req,
+    Res: () => Res,
     RouterModule: () => RouterModule,
     RouterOutlet: () => RouterOutlet,
     SIGNATURE_METADATA_KEY: () => SIGNATURE_METADATA_KEY,
     SSE_ROUTE: () => SSE_ROUTE,
+    SetMetadata: () => SetMetadata,
+    Shared: () => Shared,
     Signature: () => Signature,
     Sse: () => Sse,
-    Subject: () => Subject,
     Subscribe: () => Subscribe,
-    assert$: () => assert$,
+    UploadedFile: () => UploadedFile,
+    UploadedFiles: () => UploadedFiles,
+    UseGuards: () => UseGuards,
+    UseInterceptors: () => UseInterceptors,
+    applyDecorators: () => applyDecorators,
     batch: () => batch,
     browser: () => browser_exports,
-    catchError: () => catchError,
     collectAllProvidersFromNode: () => collectAllProvidersFromNode,
     computed: () => computed,
-    concatMap: () => concatMap,
     createComponent: () => createComponent,
     createRoot: () => createRoot,
-    debounceTime: () => debounceTime,
-    distinctUntilChanged: () => distinctUntilChanged,
     effect: () => effect,
-    filter: () => filter,
-    from: () => from,
     getCurrentInjector: () => getCurrentInjector,
+    getGuards: () => getGuards,
+    getInterceptors: () => getInterceptors,
     getSignatureMetadata: () => getSignatureMetadata,
     hasSignature: () => hasSignature,
     insert: () => insert,
-    interval: () => interval,
     isClassComponent: () => isClassComponent,
     isFragment: () => isFragment,
     isIntrinsicElement: () => isIntrinsicElement,
-    isObservable: () => isObservable,
     isSignal: () => isSignal,
     jsx: () => jsx,
     jsxs: () => jsxs,
-    map: () => map,
-    mergeMap: () => mergeMap,
-    observable: () => observable,
-    of: () => of,
+    mixin: () => mixin,
     parseSignatureSchemas: () => parseSignatureSchemas,
-    reduce: () => reduce,
-    scan: () => scan,
     setCurrentInjector: () => setCurrentInjector,
     shared: () => shared_exports,
     signal: () => signal,
-    skip: () => skip,
     spread: () => spread,
-    startWith: () => startWith,
     style: () => style,
-    switchMap: () => switchMap,
     symbolValueReplacer: () => symbolValueReplacer,
     symbolValueReviver: () => symbolValueReviver,
-    take: () => take,
-    tap: () => tap,
-    throttleTime: () => throttleTime,
     toSignal: () => toSignal,
     untracked: () => untracked
   });
@@ -146,7 +137,6 @@ var kithinjiorca = (() => {
     BOOTSTRAP: () => BOOTSTRAP,
     BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
     BaseActor: () => BaseActor,
-    BehaviorSubject: () => BehaviorSubject,
     Body: () => Body,
     COMPONENT: () => COMPONENT,
     COMPONENT_DEPS: () => COMPONENT_DEPS,
@@ -165,6 +155,7 @@ var kithinjiorca = (() => {
     EXPORTS_KEY: () => EXPORTS_KEY,
     EXPRESS_ADAPTER_HOST: () => EXPRESS_ADAPTER_HOST,
     Fragment: () => Fragment,
+    GUARDS_KEY: () => GUARDS_KEY,
     Get: () => Get,
     HTTP_METHOD_KEY: () => HTTP_METHOD_KEY,
     HandlerParamType: () => HandlerParamType,
@@ -174,6 +165,7 @@ var kithinjiorca = (() => {
     IMPORTS_KEY: () => IMPORTS_KEY,
     INJECTABLE: () => INJECTABLE,
     INJECT_TOKENS_KEY: () => INJECT_TOKENS_KEY,
+    INTERCEPTORS_KEY: () => INTERCEPTORS_KEY,
     Inject: () => Inject,
     Injectable: () => Injectable,
     Injector: () => Injector,
@@ -184,7 +176,6 @@ var kithinjiorca = (() => {
     ORCA_ELEMENT_TYPE: () => ORCA_ELEMENT_TYPE,
     ORCA_FRAGMENT_TYPE: () => ORCA_FRAGMENT_TYPE,
     OSC: () => OSC,
-    Observable: () => Observable,
     OrcaComponent: () => OrcaComponent,
     PARAMS_META_KEY: () => PARAMS_META_KEY,
     PATH_KEY: () => PATH_KEY,
@@ -194,60 +185,54 @@ var kithinjiorca = (() => {
     Post: () => Post,
     ProviderNormalizer: () => ProviderNormalizer,
     Query: () => Query,
+    REQUEST_CONTEXT: () => REQUEST_CONTEXT,
+    Req: () => Req,
+    Res: () => Res,
     SIGNATURE_METADATA_KEY: () => SIGNATURE_METADATA_KEY,
     SSE_ROUTE: () => SSE_ROUTE,
+    SetMetadata: () => SetMetadata,
+    Shared: () => Shared,
     Signature: () => Signature,
     Sse: () => Sse,
     StreamRenderer: () => StreamRenderer,
     StringRenderer: () => StringRenderer,
-    Subject: () => Subject,
     Subscribe: () => Subscribe,
+    UploadedFile: () => UploadedFile,
+    UploadedFiles: () => UploadedFiles,
+    UseGuards: () => UseGuards,
+    UseInterceptors: () => UseInterceptors,
     VNode: () => VNode,
-    assert$: () => assert$,
+    applyDecorators: () => applyDecorators,
     batch: () => batch,
-    catchError: () => catchError,
     collectAllProvidersFromNode: () => collectAllProvidersFromNode,
     computed: () => computed,
-    concatMap: () => concatMap,
     createRoot: () => createRoot,
-    debounceTime: () => debounceTime,
-    distinctUntilChanged: () => distinctUntilChanged,
     effect: () => effect,
-    filter: () => filter,
-    from: () => from,
     getCurrentInjector: () => getCurrentInjector,
+    getGuards: () => getGuards,
+    getInterceptors: () => getInterceptors,
     getSignatureMetadata: () => getSignatureMetadata,
     hasSignature: () => hasSignature,
-    interval: () => interval,
     isClassComponent: () => isClassComponent,
     isFragment: () => isFragment,
     isIntrinsicElement: () => isIntrinsicElement,
-    isObservable: () => isObservable,
     isSignal: () => isSignal,
     jsx: () => jsx,
     jsxs: () => jsxs,
-    map: () => map,
-    mergeMap: () => mergeMap,
-    observable: () => observable,
-    of: () => of,
+    mixin: () => mixin,
     parseSignatureSchemas: () => parseSignatureSchemas,
-    reduce: () => reduce,
-    scan: () => scan,
     setCurrentInjector: () => setCurrentInjector,
     signal: () => signal,
-    skip: () => skip,
-    startWith: () => startWith,
     store: () => store,
-    switchMap: () => switchMap,
     symbolValueReplacer: () => symbolValueReplacer,
     symbolValueReviver: () => symbolValueReviver,
-    take: () => take,
-    tap: () => tap,
-    throttleTime: () => throttleTime,
     toSignal: () => toSignal,
     untracked: () => untracked
   });
 
+  // src/shared/decorators.ts
+  var import_uid = __require("uid");
+
   // src/shared/store.ts
   var Store = class {
     constructor() {
@@ -292,6 +277,9 @@ var kithinjiorca = (() => {
   var SIGNATURE_METADATA_KEY = /* @__PURE__ */ Symbol("orca:signature:schemas");
   var SSE_ROUTE = /* @__PURE__ */ Symbol("orca:sse:route");
   var EVENT_HANDLER = /* @__PURE__ */ Symbol("orca:event:handler");
+  var INTERCEPTORS_KEY = /* @__PURE__ */ Symbol("interceptors");
+  var GUARDS_KEY = /* @__PURE__ */ Symbol("guards");
+  var REQUEST_CONTEXT = /* @__PURE__ */ Symbol("orca:request");
   var ERROR_ELEMENT = /* @__PURE__ */ Symbol.for("orca:error");
   var ORCA_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("orca:element");
   var ORCA_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("orca:fragment");
@@ -306,6 +294,8 @@ var kithinjiorca = (() => {
     HandlerParamType2["HEADERS"] = "HEADERS";
     HandlerParamType2["REQUEST"] = "REQUEST";
     HandlerParamType2["RESPONSE"] = "RESPONSE";
+    HandlerParamType2["FILE"] = "FILE";
+    HandlerParamType2["FILES"] = "FILES";
     return HandlerParamType2;
   })(HandlerParamType || {});
   var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
@@ -331,6 +321,13 @@ var kithinjiorca = (() => {
       return target;
     };
   }
+  function mixin(mixinClass) {
+    Object.defineProperty(mixinClass, "name", {
+      value: (0, import_uid.uid)(21)
+    });
+    Injectable()(mixinClass);
+    return mixinClass;
+  }
   function Component(params = {}) {
     return function(target) {
       store.update("components", (current) => {
@@ -347,7 +344,7 @@ var kithinjiorca = (() => {
       }
       Reflect.defineMetadata(COMPONENT, true, target);
       Reflect.defineMetadata(COMPONENT_PROVIDERS, params.providers || [], target);
-      Reflect.defineMetadata(COMPONENT_DEPS, params.deps || [], target);
+      Reflect.defineMetadata(COMPONENT_DEPS, params.inject || [], target);
       return target;
     };
   }
@@ -391,6 +388,18 @@ var kithinjiorca = (() => {
   function Query(key) {
     return getHandlerParamDecorator("QUERY" /* QUERY */, key);
   }
+  function UploadedFile() {
+    return getHandlerParamDecorator("FILE" /* FILE */);
+  }
+  function UploadedFiles() {
+    return getHandlerParamDecorator("FILES" /* FILES */);
+  }
+  function Req() {
+    return getHandlerParamDecorator("REQUEST" /* REQUEST */);
+  }
+  function Res() {
+    return getHandlerParamDecorator("RESPONSE" /* RESPONSE */);
+  }
   function getRouteDecorator(httpMethod, path) {
     return function(target, key, descriptor) {
       Reflect.defineMetadata(HTTP_METHOD_KEY, httpMethod, target, key);
@@ -410,6 +419,10 @@ var kithinjiorca = (() => {
       Reflect.defineMetadata(HTTP_METHOD_KEY, "get" /* GET */, target, propertyKey);
     };
   }
+  function Shared() {
+    return function(target, _propertyKey, parameterIndex) {
+    };
+  }
   function Subscribe(pattern) {
     return function(target, propertyKey, descriptor) {
       Reflect.defineMetadata(EVENT_HANDLER, pattern, target, propertyKey);
@@ -448,6 +461,61 @@ var kithinjiorca = (() => {
     }
     return { paramSchemas, returnSchema };
   }
+  function UseInterceptors(...interceptors) {
+    return function(target, propertyKey, descriptor) {
+      if (propertyKey && descriptor) {
+        const existing = Reflect.getMetadata(INTERCEPTORS_KEY, target, propertyKey) || [];
+        Reflect.defineMetadata(INTERCEPTORS_KEY, [...existing, ...interceptors], target, propertyKey);
+      } else {
+        const existing = Reflect.getMetadata(INTERCEPTORS_KEY, target) || [];
+        Reflect.defineMetadata(INTERCEPTORS_KEY, [...existing, ...interceptors], target);
+      }
+    };
+  }
+  function getInterceptors(target, propertyKey) {
+    const classInterceptors = Reflect.getMetadata(INTERCEPTORS_KEY, target.constructor) || [];
+    const methodInterceptors = Reflect.getMetadata(INTERCEPTORS_KEY, target, propertyKey) || [];
+    return [...classInterceptors, ...methodInterceptors];
+  }
+  function UseGuards(...guards) {
+    return function(target, propertyKey, descriptor) {
+      if (propertyKey && descriptor) {
+        const existing = Reflect.getMetadata(GUARDS_KEY, target, propertyKey) || [];
+        Reflect.defineMetadata(GUARDS_KEY, [...existing, ...guards], target, propertyKey);
+      } else {
+        const existing = Reflect.getMetadata(GUARDS_KEY, target) || [];
+        Reflect.defineMetadata(GUARDS_KEY, [...existing, ...guards], target);
+      }
+    };
+  }
+  function getGuards(target, propertyKey) {
+    const classGuards = Reflect.getMetadata(GUARDS_KEY, target.constructor) || [];
+    const methodGuards = Reflect.getMetadata(GUARDS_KEY, target, propertyKey) || [];
+    return [...classGuards, ...methodGuards];
+  }
+  var SetMetadata = (metadataKey, metadataValue) => {
+    const decoratorFactory = (target, key, descriptor) => {
+      if (descriptor) {
+        Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+        return descriptor;
+      }
+      Reflect.defineMetadata(metadataKey, metadataValue, target);
+      return target;
+    };
+    decoratorFactory.KEY = metadataKey;
+    return decoratorFactory;
+  };
+  function applyDecorators(...decorators) {
+    return (target, propertyKey, descriptor) => {
+      for (const decorator of decorators) {
+        if (target instanceof Function && !descriptor) {
+          decorator(target);
+          continue;
+        }
+        decorator(target, propertyKey, descriptor);
+      }
+    };
+  }
 
   // src/shared/module/node.ts
   var ProviderNormalizer = class {
@@ -509,10 +577,11 @@ var kithinjiorca = (() => {
     }
     createNode(moduleOrDynamic) {
       const target = this.isDynamicModule(moduleOrDynamic) ? moduleOrDynamic.module : moduleOrDynamic;
-      if (this.nodes.has(target.name))
-        return this.nodes.get(target.name);
-      const node = new Node2(target.name);
-      this.nodes.set(target.name, node);
+      const nodeKey = this.getNodeKey(moduleOrDynamic, target);
+      if (this.nodes.has(nodeKey))
+        return this.nodes.get(nodeKey);
+      const node = new Node2(nodeKey);
+      this.nodes.set(nodeKey, node);
       const imports = this.getImports(moduleOrDynamic);
       node.setChildren(imports.map((imp) => this.createNode(imp)));
       const providers = this.getProviders(moduleOrDynamic);
@@ -551,6 +620,38 @@ var kithinjiorca = (() => {
       this.getExports(moduleOrDynamic).forEach((exp) => node.addExport(exp));
       return node;
     }
+    getNodeKey(moduleOrDynamic, target) {
+      if (this.isDynamicModule(moduleOrDynamic)) {
+        if (moduleOrDynamic.__uniqueId) {
+          return `${target.name}:${moduleOrDynamic.__uniqueId}`;
+        }
+        const autoId = this.generateAutoId(moduleOrDynamic);
+        if (autoId) {
+          return `${target.name}:${autoId}`;
+        }
+      }
+      return target.name;
+    }
+    generateAutoId(dynamicModule) {
+      const parts = [];
+      if (dynamicModule.providers && dynamicModule.providers.length > 0) {
+        const providerTokens = dynamicModule.providers.map((p) => this.getProviderToken(p)).map((t) => typeof t === "function" ? t.name : String(t)).sort().join(",");
+        parts.push(`p:${providerTokens}`);
+      }
+      if (dynamicModule.exports && dynamicModule.exports.length > 0) {
+        const exportTokens = dynamicModule.exports.map((t) => typeof t === "function" ? t.name : String(t)).sort().join(",");
+        parts.push(`e:${exportTokens}`);
+      }
+      if (dynamicModule.controllers && dynamicModule.controllers.length > 0) {
+        const controllerNames = dynamicModule.controllers.map((c) => c.name).sort().join(",");
+        parts.push(`c:${controllerNames}`);
+      }
+      if (dynamicModule.declarations && dynamicModule.declarations.length > 0) {
+        const declarationNames = dynamicModule.declarations.map((d) => d.name).sort().join(",");
+        parts.push(`d:${declarationNames}`);
+      }
+      return parts.length > 0 ? parts.join("|") : null;
+    }
     validate(rootNode) {
       const errors = [];
       const allNodes = /* @__PURE__ */ new Map();
@@ -647,14 +748,23 @@ var kithinjiorca = (() => {
       return typeof provider === "function" ? provider : provider.provide;
     }
     extractDependencies(item) {
-      if (typeof item === "object" && "deps" in item && item.deps)
-        return item.deps;
+      if (typeof item === "object" && "inject" in item && item.inject) {
+        return item.inject.filter((dep) => {
+          if (this.isOptionalDependency(dep)) {
+            return !dep.optional;
+          }
+          return true;
+        }).map((dep) => this.isOptionalDependency(dep) ? dep.token : dep);
+      }
       if (typeof item === "object" && item.useClass)
         return this.getConstructorDependencies(item.useClass);
       if (typeof item === "function")
         return this.getConstructorDependencies(item);
       return [];
     }
+    isOptionalDependency(dep) {
+      return typeof dep === "object" && "token" in dep && "optional" in dep;
+    }
     getConstructorDependencies(constructor) {
       const injectTokens = Reflect.getOwnMetadata(INJECT_TOKENS_KEY, constructor) || /* @__PURE__ */ new Map();
       const paramTypes = Reflect.getMetadata(DESIGN_PARAMTYPES, constructor) || [];
@@ -729,9 +839,10 @@ var kithinjiorca = (() => {
   };
 
   // src/shared/module/injector.ts
-  var Injector = class {
+  var Injector = class _Injector {
     constructor(providers, parent) {
       this.instanceCache = /* @__PURE__ */ new Map();
+      this.promiseCache = /* @__PURE__ */ new Map();
       this.providerMap = /* @__PURE__ */ new Map();
       this.parent = parent;
       providers.forEach((p) => {
@@ -739,14 +850,20 @@ var kithinjiorca = (() => {
         this.providerMap.set(normalized.provide, normalized);
       });
     }
+    createChild(providers) {
+      return new _Injector(providers, this);
+    }
     addProvider(provider) {
       const normalized = ProviderNormalizer.normalize(provider);
       this.providerMap.set(normalized.provide, normalized);
     }
-    resolve(token) {
+    async resolve(token) {
       if (this.instanceCache.has(token)) {
         return this.instanceCache.get(token);
       }
+      if (this.promiseCache.has(token)) {
+        return this.promiseCache.get(token);
+      }
       const provider = this.providerMap.get(token);
       if (!provider) {
         if (this.parent) {
@@ -756,23 +873,101 @@ var kithinjiorca = (() => {
           `No provider for token: ${typeof token === "function" ? token.name : String(token)}`
         );
       }
-      const instance = this.createInstance(provider);
+      const instancePromise = this.createInstance(provider);
+      this.promiseCache.set(token, instancePromise);
+      try {
+        const instance = await instancePromise;
+        if (provider.scope !== "transient") {
+          this.instanceCache.set(token, instance);
+        }
+        return instance;
+      } finally {
+        this.promiseCache.delete(token);
+      }
+    }
+    resolveSync(token) {
+      if (this.instanceCache.has(token)) {
+        return this.instanceCache.get(token);
+      }
+      const provider = this.providerMap.get(token);
+      if (!provider) {
+        if (this.parent) {
+          return this.parent.resolveSync(token);
+        }
+        throw new Error(
+          `No provider for token: ${typeof token === "function" ? token.name : String(token)}`
+        );
+      }
+      const instance = this.createInstanceSync(provider);
       if (provider.scope !== "transient") {
         this.instanceCache.set(token, instance);
       }
       return instance;
     }
-    createInstance(provider) {
-      if ("useValue" in provider && provider.useValue !== void 0)
-        return provider.useValue;
+    async createInstance(provider) {
+      if ("useValue" in provider) return provider.useValue;
       if (provider.useExisting) return this.resolve(provider.useExisting);
       if (provider.useFactory) {
-        const deps2 = (provider.deps || []).map((d) => this.resolve(d));
+        const deps2 = await Promise.all(
+          (provider.inject || []).map((d) => this.resolveDependency(d))
+        );
         return provider.useFactory(...deps2);
       }
       const Ctor = provider.useClass || provider.provide;
-      const deps = provider.deps || this.getConstructorDeps(Ctor);
-      return new Ctor(...deps.map((d) => this.resolve(d)));
+      const deps = provider.inject || this.getConstructorDeps(Ctor);
+      const resolvedDeps = await Promise.all(
+        deps.map((d) => this.resolveDependency(d))
+      );
+      return new Ctor(...resolvedDeps);
+    }
+    createInstanceSync(provider) {
+      if ("useValue" in provider && provider.useValue !== void 0)
+        return provider.useValue;
+      if (provider.useExisting) return this.resolveSync(provider.useExisting);
+      if (provider.useFactory) {
+        const deps2 = (provider.inject || []).map(
+          (d) => this.resolveDependencySync(d)
+        );
+        const result = provider.useFactory(...deps2);
+        if (result instanceof Promise) {
+          throw new Error(
+            `Async factory detected but resolveSync() was called. Use resolve() instead.`
+          );
+        }
+        return result;
+      }
+      const Ctor = provider.useClass || provider.provide;
+      const deps = provider.inject || this.getConstructorDeps(Ctor);
+      return new Ctor(...deps.map((d) => this.resolveDependencySync(d)));
+    }
+    async resolveDependency(dep) {
+      if (this.isOptionalDependency(dep)) {
+        try {
+          return await this.resolve(dep.token);
+        } catch (error) {
+          if (dep.optional) {
+            return void 0;
+          }
+          throw error;
+        }
+      }
+      return this.resolve(dep);
+    }
+    resolveDependencySync(dep) {
+      if (this.isOptionalDependency(dep)) {
+        try {
+          return this.resolveSync(dep.token);
+        } catch (error) {
+          if (dep.optional) {
+            return void 0;
+          }
+          throw error;
+        }
+      }
+      return this.resolveSync(dep);
+    }
+    isOptionalDependency(dep) {
+      return typeof dep === "object" && dep !== null && "token" in dep && "optional" in dep;
     }
     getConstructorDeps(ctor) {
       const injectTokens = Reflect.getOwnMetadata(INJECT_TOKENS_KEY, ctor) || /* @__PURE__ */ new Map();
@@ -944,14 +1139,14 @@ var kithinjiorca = (() => {
       return "";
     }
     escapeHtml(text) {
-      const map2 = {
+      const map = {
         "&": "&",
         "<": "&lt;",
         ">": "&gt;",
         '"': "&quot;",
         "'": "&#039;"
       };
-      return text.replace(/[&<>"']/g, (m) => map2[m]);
+      return text.replace(/[&<>"']/g, (m) => map[m]);
     }
   };
 
@@ -1065,7 +1260,7 @@ var kithinjiorca = (() => {
           );
         }
       }
-      const instance = componentInjector.resolve(ComponentClass);
+      const instance = componentInjector.resolveSync(ComponentClass);
       const mergedProps = Object.create(
         Object.getPrototypeOf(instance.props || {})
       );
@@ -1433,86 +1628,7 @@ var kithinjiorca = (() => {
     }
   }
 
-  // src/shared/observable/observable.ts
-  var Observable = class {
-    constructor(producer) {
-      this.producer = producer;
-      this.__isObservable = true;
-    }
-    subscribe(observerOrNext, error, complete) {
-      const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-      let cleanup;
-      let isUnsubscribed = false;
-      if (this.producer) {
-        try {
-          cleanup = this.producer(observer);
-        } catch (err) {
-          if (observer.error) {
-            try {
-              observer.error(err);
-            } catch (e) {
-              console.error("Error in error handler during subscription:", e);
-            }
-          } else {
-            throw err;
-          }
-        }
-      }
-      return {
-        unsubscribe: () => {
-          if (isUnsubscribed) return;
-          isUnsubscribed = true;
-          if (cleanup) {
-            try {
-              cleanup();
-            } catch (err) {
-              console.error("Error during cleanup:", err);
-            }
-          }
-        }
-      };
-    }
-    pipe(...operations) {
-      if (operations.length === 0) {
-        return this;
-      }
-      return operations.reduce((prev, fn) => fn(prev), this);
-    }
-  };
-  function from(iterable) {
-    return new Observable((observer) => {
-      try {
-        for (const value of iterable) {
-          observer.next(value);
-        }
-        observer.complete?.();
-      } catch (err) {
-        observer.error?.(err);
-      }
-    });
-  }
-  function interval(ms) {
-    return new Observable((observer) => {
-      let count = 0;
-      const id = setInterval(() => {
-        observer.next(count++);
-      }, ms);
-      return () => clearInterval(id);
-    });
-  }
-  function of(...values) {
-    return new Observable((observer) => {
-      try {
-        values.forEach((value) => observer.next(value));
-        observer.complete?.();
-      } catch (err) {
-        observer.error?.(err);
-      }
-    });
-  }
-  function observable(producer) {
-    return new Observable(producer);
-  }
+  // src/shared/signal/utils.ts
   function toSignal(obs, instance) {
     const sig = signal(void 0);
     const subst = obs.subscribe((val) => {
@@ -1524,480 +1640,6 @@ var kithinjiorca = (() => {
     ];
     return sig;
   }
-  function isObservable(value) {
-    return value && value.__isObservable === true;
-  }
-  function map(fn) {
-    return (source) => {
-      return new Observable((observer) => {
-        const subscription = source.subscribe(
-          (value) => {
-            try {
-              observer.next(fn(value));
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function filter(predicate) {
-    return (source) => {
-      return new Observable((observer) => {
-        const subscription = source.subscribe(
-          (value) => {
-            try {
-              if (predicate(value)) {
-                observer.next(value);
-              }
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function tap(fn) {
-    return (source) => {
-      return new Observable((observer) => {
-        const subscription = source.subscribe(
-          (value) => {
-            try {
-              fn(value);
-              observer.next(value);
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function take(count) {
-    return (source) => {
-      return new Observable((observer) => {
-        let taken = 0;
-        const subscription = source.subscribe(
-          (value) => {
-            if (taken < count) {
-              observer.next(value);
-              taken++;
-              if (taken === count) {
-                observer.complete?.();
-                subscription.unsubscribe();
-              }
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function skip(count) {
-    return (source) => {
-      return new Observable((observer) => {
-        let skipped = 0;
-        const subscription = source.subscribe(
-          (value) => {
-            if (skipped < count) {
-              skipped++;
-            } else {
-              observer.next(value);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function debounceTime(ms) {
-    return (source) => {
-      return new Observable((observer) => {
-        let timeoutId;
-        const subscription = source.subscribe(
-          (value) => {
-            clearTimeout(timeoutId);
-            timeoutId = setTimeout(() => {
-              observer.next(value);
-            }, ms);
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => {
-          clearTimeout(timeoutId);
-          subscription.unsubscribe();
-        };
-      });
-    };
-  }
-  function throttleTime(ms) {
-    return (source) => {
-      return new Observable((observer) => {
-        let lastEmit = 0;
-        const subscription = source.subscribe(
-          (value) => {
-            const now = Date.now();
-            if (now - lastEmit >= ms) {
-              lastEmit = now;
-              observer.next(value);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function distinctUntilChanged(compare) {
-    return (source) => {
-      return new Observable((observer) => {
-        let hasLast = false;
-        let last;
-        const subscription = source.subscribe(
-          (value) => {
-            const isDistinct = !hasLast || (compare ? !compare(last, value) : last !== value);
-            if (isDistinct) {
-              hasLast = true;
-              last = value;
-              observer.next(value);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function switchMap(fn) {
-    return (source) => {
-      return new Observable((observer) => {
-        let innerSubscription = null;
-        const outerSubscription = source.subscribe(
-          (value) => {
-            if (innerSubscription) {
-              innerSubscription.unsubscribe();
-            }
-            try {
-              const innerObservable = fn(value);
-              innerSubscription = innerObservable.subscribe(
-                (innerValue) => observer.next(innerValue),
-                (err) => observer.error?.(err)
-              );
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => {
-          if (innerSubscription) {
-            innerSubscription.unsubscribe();
-          }
-          outerSubscription.unsubscribe();
-        };
-      });
-    };
-  }
-  function mergeMap(fn) {
-    return (source) => {
-      return new Observable((observer) => {
-        const innerSubscriptions = [];
-        let outerComplete = false;
-        let activeCount = 0;
-        const checkComplete = () => {
-          if (outerComplete && activeCount === 0) {
-            observer.complete?.();
-          }
-        };
-        const outerSubscription = source.subscribe(
-          (value) => {
-            try {
-              const innerObservable = fn(value);
-              activeCount++;
-              const innerSub = innerObservable.subscribe(
-                (innerValue) => observer.next(innerValue),
-                (err) => observer.error?.(err),
-                () => {
-                  activeCount--;
-                  checkComplete();
-                }
-              );
-              innerSubscriptions.push(innerSub);
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => {
-            outerComplete = true;
-            checkComplete();
-          }
-        );
-        return () => {
-          innerSubscriptions.forEach((sub) => sub.unsubscribe());
-          outerSubscription.unsubscribe();
-        };
-      });
-    };
-  }
-  function concatMap(fn) {
-    return (source) => {
-      return new Observable((observer) => {
-        const queue = [];
-        let innerSubscription = null;
-        let outerComplete = false;
-        let isProcessing = false;
-        const processNext = () => {
-          if (isProcessing || queue.length === 0) {
-            if (outerComplete && queue.length === 0) {
-              observer.complete?.();
-            }
-            return;
-          }
-          isProcessing = true;
-          const value = queue.shift();
-          try {
-            const innerObservable = fn(value);
-            innerSubscription = innerObservable.subscribe(
-              (innerValue) => observer.next(innerValue),
-              (err) => observer.error?.(err),
-              () => {
-                isProcessing = false;
-                processNext();
-              }
-            );
-          } catch (err) {
-            observer.error?.(err);
-          }
-        };
-        const outerSubscription = source.subscribe(
-          (value) => {
-            queue.push(value);
-            processNext();
-          },
-          (err) => observer.error?.(err),
-          () => {
-            outerComplete = true;
-            if (queue.length === 0 && !isProcessing) {
-              observer.complete?.();
-            }
-          }
-        );
-        return () => {
-          if (innerSubscription) {
-            innerSubscription.unsubscribe();
-          }
-          outerSubscription.unsubscribe();
-        };
-      });
-    };
-  }
-  function catchError(handler) {
-    return (source) => {
-      return new Observable((observer) => {
-        const subscription = source.subscribe(
-          (value) => observer.next(value),
-          (err) => {
-            try {
-              const fallback = handler(err);
-              const fallbackSub = fallback.subscribe(
-                (value) => observer.next(value),
-                (e) => observer.error?.(e),
-                () => observer.complete?.()
-              );
-              subscription.__fallback = fallbackSub;
-            } catch (e) {
-              observer.error?.(e);
-            }
-          },
-          () => observer.complete?.()
-        );
-        return () => {
-          if (subscription.__fallback) {
-            subscription.__fallback.unsubscribe();
-          }
-          subscription.unsubscribe();
-        };
-      });
-    };
-  }
-  function startWith(...values) {
-    return (source) => {
-      return new Observable((observer) => {
-        values.forEach((value) => observer.next(value));
-        const subscription = source.subscribe(
-          (value) => observer.next(value),
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function scan(accumulator, seed) {
-    return (source) => {
-      return new Observable((observer) => {
-        let acc = seed;
-        const subscription = source.subscribe(
-          (value) => {
-            try {
-              acc = accumulator(acc, value);
-              observer.next(acc);
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => observer.complete?.()
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-  function reduce(accumulator, seed) {
-    return (source) => {
-      return new Observable((observer) => {
-        let acc = seed;
-        const subscription = source.subscribe(
-          (value) => {
-            try {
-              acc = accumulator(acc, value);
-            } catch (err) {
-              observer.error?.(err);
-            }
-          },
-          (err) => observer.error?.(err),
-          () => {
-            observer.next(acc);
-            observer.complete?.();
-          }
-        );
-        return () => subscription.unsubscribe();
-      });
-    };
-  }
-
-  // src/shared/observable/subject.ts
-  var Subject = class extends Observable {
-    constructor() {
-      super();
-      this.subscribers = /* @__PURE__ */ new Set();
-      this._isCompleted = false;
-      this._hasError = false;
-      this._thrownError = null;
-    }
-    asObservable() {
-      return new Observable((observer) => {
-        const subscription = this.subscribe(observer);
-        return () => subscription.unsubscribe();
-      });
-    }
-    subscribe(observerOrNext, error, complete) {
-      if (this._isCompleted) {
-        const obs = typeof observerOrNext === "function" ? { complete } : observerOrNext;
-        obs.complete?.();
-        return { unsubscribe: () => {
-        } };
-      }
-      if (this._hasError) {
-        return { unsubscribe: () => {
-        } };
-      }
-      const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-      this.subscribers.add(observer);
-      return {
-        unsubscribe: () => {
-          this.subscribers.delete(observer);
-        }
-      };
-    }
-    next(value) {
-      if (this._isCompleted || this._hasError) return;
-      const currentSubscribers = Array.from(this.subscribers);
-      currentSubscribers.forEach((observer) => {
-        if (this.subscribers.has(observer)) {
-          try {
-            observer.next(value);
-          } catch (err) {
-            console.error("Error in observer:", err);
-          }
-        }
-      });
-    }
-    error(err) {
-      if (this._isCompleted || this._hasError) return;
-      this._hasError = true;
-      this._thrownError = err;
-      for (const observer of this.subscribers) {
-        observer.error?.(err);
-      }
-      this.subscribers.clear();
-    }
-    complete() {
-      if (this._isCompleted || this._hasError) return;
-      this._isCompleted = true;
-      const currentSubscribers = Array.from(this.subscribers);
-      currentSubscribers.forEach((observer) => {
-        if (observer.complete) {
-          try {
-            observer.complete();
-          } catch (err) {
-            console.error("Error in complete handler:", err);
-          }
-        }
-      });
-      this.subscribers.clear();
-    }
-  };
-
-  // src/shared/observable/bsubject.ts
-  var BehaviorSubject = class extends Subject {
-    constructor(initialValue) {
-      super();
-      this._value = initialValue;
-    }
-    get $value() {
-      return this._value;
-    }
-    next(value) {
-      this._value = value;
-      super.next(value);
-    }
-    subscribe(observerOrNext, error, complete) {
-      const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-      if (this._hasError) {
-        observer.error?.(this._thrownError);
-        return { unsubscribe: () => {
-        } };
-      }
-      if (this._isCompleted) {
-        observer.complete?.();
-        return { unsubscribe: () => {
-        } };
-      }
-      observer.next(this._value);
-      return super.subscribe(observer);
-    }
-  };
 
   // src/shared/component.ts
   var OrcaComponent = class {
@@ -2015,6 +1657,7 @@ var kithinjiorca = (() => {
   };
 
   // src/shared/module_libs/http_client/module.ts
+  var import_rxjs = __require("rxjs");
   var __decorate = function(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2023,7 +1666,7 @@ var kithinjiorca = (() => {
   };
   var HttpClient = class HttpClient2 {
     get(url, { stream = "json", reviver, init } = {}) {
-      return new Observable((subscriber) => {
+      return new import_rxjs.Observable((subscriber) => {
         const controller = new AbortController();
         fetch(url, {
           method: "GET",
@@ -2462,9 +2105,21 @@ var kithinjiorca = (() => {
         register2(ComponentClass, injector);
         const cleanProps = { ...props };
         delete cleanProps.__clientComponent;
-        const instance = injector.resolve(ComponentClass);
+        const instance = await injector.resolve(ComponentClass);
         instance.__injector = injector;
-        instance.props = cleanProps;
+        const mergedProps = Object.create(
+          Object.getPrototypeOf(instance.props || {})
+        );
+        Object.defineProperties(
+          mergedProps,
+          Object.getOwnPropertyDescriptors(instance.props || {})
+        );
+        Object.defineProperties(
+          mergedProps,
+          Object.getOwnPropertyDescriptors(cleanProps || {})
+        );
+        instance.props = mergedProps;
+        instance.onInit?.();
         if (typeof instance.build !== "function") {
           throw new Error(`Component ${name} does not implement build()`);
         }
@@ -2478,11 +2133,6 @@ var kithinjiorca = (() => {
     }
   };
 
-  // src/shared/macros/index.ts
-  function assert$(context) {
-    return context?.factory.createStringLiteral("assert");
-  }
-
   // src/shared/providers/actor.ts
   var BaseActor = class {
     constructor() {
@@ -2606,6 +2256,7 @@ var kithinjiorca = (() => {
   };
 
   // src/browser/modules/router_module/navigate.ts
+  var import_rxjs2 = __require("rxjs");
   var __decorate3 = function(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2627,30 +2278,39 @@ var kithinjiorca = (() => {
       this.STORAGE_KEY = "navigate_stack";
       const savedState = this.loadFromStorage();
       const historyCursor = history.state?.cursor;
-      if (savedState && historyCursor !== void 0) {
+      if (savedState && historyCursor !== void 0 && savedState.routes[historyCursor]) {
         this.cursor = historyCursor;
-        const restoredPages = savedState.routes.map(() => null);
-        const currentRoute = window.location.pathname + window.location.search;
-        const stream = this.createStreamForRoute(currentRoute);
-        restoredPages[this.cursor] = stream;
-        this.pages = new BehaviorSubject(restoredPages);
+        const restoredPages = savedState.routes.map((routeData, idx) => ({
+          content: idx === this.cursor ? this.createStreamForRoute(routeData.path) : null,
+          isOverlay: routeData.isOverlay,
+          route: routeData.path
+        }));
+        this.pages = new import_rxjs2.BehaviorSubject(restoredPages);
       } else {
-        const initialStream = this.createStreamForCurrentUrl();
-        this.pages = new BehaviorSubject([initialStream]);
+        const initialPath = window.location.pathname + window.location.search;
+        const initialStream = this.createStreamForRoute(initialPath);
         this.cursor = 0;
-        history.replaceState({ cursor: 0 }, "");
+        this.pages = new import_rxjs2.BehaviorSubject([
+          {
+            content: initialStream,
+            isOverlay: false,
+            route: initialPath
+          }
+        ]);
+        history.replaceState({ cursor: 0 }, "", initialPath);
         this.saveToStorage();
       }
+      this.initListeners();
+    }
+    initListeners() {
       window.addEventListener("popstate", (e) => {
         const newCursor = e.state?.cursor ?? 0;
-        this.cursor = newCursor;
-        const currentPages = [...this.pages.$value || []];
-        if (!currentPages[newCursor]) {
-          const savedState2 = this.loadFromStorage();
-          const route = savedState2?.routes[newCursor] || window.location.pathname + window.location.search;
-          const stream = this.createStreamForRoute(route);
-          currentPages[newCursor] = stream;
+        const currentPages = [...this.pages.value];
+        if (currentPages[newCursor] && !currentPages[newCursor].content) {
+          const route = currentPages[newCursor].route || window.location.pathname + window.location.search;
+          currentPages[newCursor].content = this.createStreamForRoute(route);
         }
+        this.cursor = newCursor;
         this.pages.next(currentPages);
       });
     }
@@ -2664,75 +2324,77 @@ var kithinjiorca = (() => {
     }
     saveToStorage() {
       try {
-        const currentPages = this.pages.$value || [];
-        const routes = currentPages.map((page, index) => {
-          if (page && typeof page === "object" && "__route" in page) {
-            return page.__route;
-          }
-          const savedState = this.loadFromStorage();
-          return savedState?.routes[index] || "";
-        });
         const state = {
-          routes,
+          routes: this.pages.value.map((p) => ({
+            path: p.route || "",
+            isOverlay: p.isOverlay
+          })),
           cursor: this.cursor
         };
         localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));
-      } catch {
+      } catch (e) {
+        console.error("Navigation persistence failed", e);
       }
     }
     createStreamForRoute(route) {
       const http = new HttpClient();
       let url = this.oscUrl;
       if (route && route !== "/") {
-        url = `${this.oscUrl}?c=${encodeURIComponent(route)}`;
+        const separator = url.includes("?") ? "&" : "?";
+        url = `${url}${separator}c=${encodeURIComponent(route)}`;
       }
       return http.post(url, {
         stream: "ndjson",
         reviver: symbolValueReviver
       });
     }
-    createStreamForCurrentUrl() {
-      const path = window.location.pathname;
-      const search = window.location.search;
-      const fullPath = search ? `${path}${search}` : path;
-      return this.createStreamForRoute(fullPath);
-    }
     go(path) {
       const stream = this.createStreamForRoute(path);
       stream.__route = path;
-      this.push(stream);
+      this.push(stream, false);
     }
-    push(item) {
-      const currentPages = this.pages.$value || [];
+    push(item, isOverlay = false) {
+      const currentPages = this.pages.value || [];
       const newPages = currentPages.slice(0, this.cursor + 1);
       let route = "";
       if (item && typeof item === "object" && "__route" in item) {
         route = item.__route;
       }
       this.cursor++;
-      newPages.push(item);
-      history.pushState({ cursor: this.cursor }, "", route);
+      newPages.push({
+        content: item,
+        isOverlay,
+        route
+      });
+      history.pushState({ cursor: this.cursor }, "", route || void 0);
       this.pages.next(newPages);
       this.saveToStorage();
     }
+    pushOverlay(item) {
+      this.push(item, true);
+    }
+    pop() {
+      if (this.canGoBack()) {
+        history.back();
+      }
+    }
     replace(item) {
-      const currentPages = [...this.pages.$value || []];
-      currentPages[this.cursor] = item;
-      history.replaceState({ cursor: this.cursor }, "");
-      this.pages.next(currentPages);
-      this.saveToStorage();
+      const currentPages = [...this.pages.value || []];
+      if (currentPages[this.cursor]) {
+        currentPages[this.cursor].content = item;
+        this.pages.next(currentPages);
+        this.saveToStorage();
+      }
     }
     resolveStream(index, element) {
-      const currentPages = [...this.pages.$value || []];
+      const currentPages = [...this.pages.value || []];
       if (index >= 0 && index < currentPages.length) {
-        currentPages[index] = element;
+        currentPages[index].content = element;
         this.pages.next(currentPages);
       }
     }
     goBack() {
-      if (this.canGoBack()) {
-        history.back();
-      }
+      this.pop();
     }
     goForward() {
       if (this.canGoForward()) {
@@ -2743,17 +2405,22 @@ var kithinjiorca = (() => {
       return this.cursor > 0;
     }
     canGoForward() {
-      const currentPages = this.pages.$value || [];
-      return this.cursor < currentPages.length - 1;
+      return this.cursor < (this.pages.value?.length || 0) - 1;
     }
     getCurrentPage() {
-      const currentPages = this.pages.$value || [];
-      return currentPages[this.cursor];
+      return this.pages.value[this.cursor];
     }
     clear() {
       this.cursor = 0;
-      const initialStream = this.createStreamForCurrentUrl();
-      this.pages.next([initialStream]);
+      const initialPath = window.location.pathname + window.location.search;
+      const initialStream = this.createStreamForRoute(initialPath);
+      this.pages.next([
+        {
+          content: initialStream,
+          isOverlay: false,
+          route: initialPath
+        }
+      ]);
       history.replaceState({ cursor: 0 }, "");
       this.saveToStorage();
     }
@@ -2778,42 +2445,87 @@ var kithinjiorca = (() => {
     constructor(navigate) {
       super();
       this.navigate = navigate;
-      this.activeStreamSubscription = null;
+      this.activeStreamSubscriptions = /* @__PURE__ */ new Map();
     }
     build() {
       const anchor = document.createElement("div");
+      anchor.style.position = "relative";
+      anchor.style.width = "100%";
+      anchor.style.height = "100%";
       const subscription = this.navigate.pages.subscribe((pages) => {
-        this.renderCurrentPage(anchor, pages);
+        this.renderPages(anchor, pages);
       });
       this.pushDrop(() => subscription.unsubscribe());
       this.pushDrop(() => {
-        if (this.activeStreamSubscription) {
-          this.activeStreamSubscription.unsubscribe();
-        }
+        this.activeStreamSubscriptions.forEach((info) => {
+          info.subscription.unsubscribe();
+        });
+        this.activeStreamSubscriptions.clear();
       });
       return anchor;
     }
-    renderCurrentPage(anchor, pages) {
-      const currentItem = pages[this.navigate.cursor];
-      if (!currentItem) {
-        anchor.replaceChildren();
-        return;
+    renderPages(anchor, pages) {
+      let baseIndex = this.navigate.cursor;
+      while (baseIndex > 0 && pages[baseIndex]?.isOverlay) {
+        baseIndex--;
+      }
+      anchor.replaceChildren();
+      if (pages[baseIndex]) {
+        const baseContainer = document.createElement("div");
+        baseContainer.className = "base-page";
+        baseContainer.style.width = "100%";
+        baseContainer.style.height = "100%";
+        this.renderPage(baseContainer, pages[baseIndex].content, baseIndex);
+        anchor.appendChild(baseContainer);
+      }
+      for (let i = baseIndex + 1; i <= this.navigate.cursor; i++) {
+        if (pages[i] && pages[i].isOverlay) {
+          const overlayContainer = document.createElement("div");
+          overlayContainer.className = "overlay";
+          overlayContainer.style.position = "fixed";
+          overlayContainer.style.inset = "0";
+          overlayContainer.style.zIndex = String(1e3 + (i - baseIndex));
+          this.renderPage(overlayContainer, pages[i].content, i);
+          anchor.appendChild(overlayContainer);
+        }
       }
-      if (this.activeStreamSubscription) {
-        this.activeStreamSubscription.unsubscribe();
-        this.activeStreamSubscription = null;
+      const visibleIndices = /* @__PURE__ */ new Set();
+      visibleIndices.add(baseIndex);
+      for (let i = baseIndex + 1; i <= this.navigate.cursor; i++) {
+        if (pages[i]?.isOverlay) {
+          visibleIndices.add(i);
+        }
+      }
+      this.activeStreamSubscriptions.forEach((info, index) => {
+        if (!visibleIndices.has(index)) {
+          info.subscription.unsubscribe();
+          this.activeStreamSubscriptions.delete(index);
+        }
+      });
+    }
+    renderPage(container, content, index) {
+      const existing = this.activeStreamSubscriptions.get(index);
+      if (existing) {
+        existing.subscription.unsubscribe();
+        this.activeStreamSubscriptions.delete(index);
+      }
+      if (!content) {
+        container.replaceChildren();
+        return;
       }
-      if (this.isObservable(currentItem)) {
-        this.renderStream(anchor, currentItem);
+      if (this.isObservable(content)) {
+        this.renderStream(container, content, index);
       } else {
-        anchor.replaceChildren(currentItem);
+        container.replaceChildren(content);
       }
     }
-    renderStream(anchor, stream) {
+    renderStream(container, stream, index) {
       const root = document.createElement("div");
-      anchor.replaceChildren(root);
+      root.style.width = "100%";
+      root.style.height = "100%";
+      container.replaceChildren(root);
       const osc = new OSC(root);
-      this.activeStreamSubscription = stream.subscribe((jsx2) => {
+      const subscription = stream.subscribe((jsx2) => {
         const action = jsx2.action || "insert";
         if (action === "insert") {
           osc.handleInsert(jsx2);
@@ -2824,11 +2536,14 @@ var kithinjiorca = (() => {
         }
       }, (error) => {
         console.error("Stream error:", error);
+        container.innerHTML = `<div>Error loading page: ${error.message}</div>`;
+        this.activeStreamSubscriptions.delete(index);
       }, () => {
         const resolvedElement = osc.tree.dom;
-        this.navigate.resolveStream(this.navigate.cursor, resolvedElement);
-        this.activeStreamSubscription = null;
+        this.navigate.resolveStream(index, resolvedElement);
+        this.activeStreamSubscriptions.delete(index);
       });
+      this.activeStreamSubscriptions.set(index, { subscription, index });
     }
     isObservable(obj) {
       return obj && typeof obj.subscribe === "function";
@@ -2888,7 +2603,7 @@ var kithinjiorca = (() => {
     static instantiateEagerProviders(appNode, injector) {
       appNode.traverse((node) => {
         const providers = [...node.getProviders().values()];
-        providers.filter((provider) => provider.eager).forEach((p) => injector.resolve(p.provide));
+        providers.filter((provider) => provider.eager).forEach(async (p) => await injector.resolve(p.provide));
       });
     }
   };
@@ -2900,8 +2615,8 @@ var kithinjiorca = (() => {
       }
       return bootstrap;
     }
-    static renderBootstrap(bootstrap, injector, rootElement) {
-      const instance = injector.resolve(bootstrap);
+    static async renderBootstrap(bootstrap, injector, rootElement) {
+      const instance = await injector.resolve(bootstrap);
       instance.__injector = injector;
       const childDom = instance.build();
       rootElement.appendChild(childDom);
@@ -2915,14 +2630,14 @@ var kithinjiorca = (() => {
      * @param rootElement - The DOM element to mount the application to
      * @throws {Error} If validation fails or bootstrap component is not found
      */
-    static create(rootModule, rootElement) {
+    static async create(rootModule, rootElement) {
       const compilationService = new CompilationService();
       const appNode = compilationService.compileAndValidate(rootModule);
       const rootInjector = InjectorConfigurationService.createRootInjector(appNode);
       setCurrentInjector(rootInjector);
       InjectorConfigurationService.instantiateEagerProviders(appNode, rootInjector);
       const bootstrap = BootstrapService.getBootstrapComponent(rootModule);
-      BootstrapService.renderBootstrap(bootstrap, rootInjector, rootElement);
+      await BootstrapService.renderBootstrap(bootstrap, rootInjector, rootElement);
     }
   };
 
@@ -3054,7 +2769,7 @@ var kithinjiorca = (() => {
     }
     let instance;
     try {
-      instance = injector.resolve(ComponentClass);
+      instance = injector.resolveSync(ComponentClass);
     } catch (e) {
       console.log(e);
       throw new Error(`Failed to resolve component ${ComponentClass.name}: ${e.message}`);