@kithinji/orca 1.0.26 → 1.0.29

package/dist/browser/index.mjs

@@ -17,11 +17,11 @@ var __export = (target, all) => {
   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 key2 of __getOwnPropNames(from2))
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -88,15 +88,15 @@ var require_Reflect = __commonJS({
           } : function() {
             return MakeDictionary({});
           },
-          has: downLevel ? function(map2, key2) {
-            return hasOwn.call(map2, key2);
-          } : function(map2, key2) {
-            return key2 in map2;
+          has: downLevel ? function(map, key2) {
+            return hasOwn.call(map, key2);
+          } : function(map, key2) {
+            return key2 in map;
           },
-          get: downLevel ? function(map2, key2) {
-            return hasOwn.call(map2, key2) ? map2[key2] : void 0;
-          } : function(map2, key2) {
-            return map2[key2];
+          get: downLevel ? function(map, key2) {
+            return hasOwn.call(map, key2) ? map[key2] : void 0;
+          } : function(map, key2) {
+            return map[key2];
           }
         };
         var functionPrototype = Object.getPrototypeOf(Function);
@@ -2670,7 +2670,6 @@ __export(shared_exports, {
   BOOTSTRAP: () => BOOTSTRAP,
   BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
   BaseActor: () => BaseActor,
-  BehaviorSubject: () => BehaviorSubject,
   Body: () => Body,
   COMPONENT: () => COMPONENT,
   COMPONENT_DEPS: () => COMPONENT_DEPS,
@@ -2689,6 +2688,7 @@ __export(shared_exports, {
   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,
@@ -2698,6 +2698,7 @@ __export(shared_exports, {
   IMPORTS_KEY: () => IMPORTS_KEY,
   INJECTABLE: () => INJECTABLE,
   INJECT_TOKENS_KEY: () => INJECT_TOKENS_KEY,
+  INTERCEPTORS_KEY: () => INTERCEPTORS_KEY,
   Inject: () => Inject,
   Injectable: () => Injectable,
   Injector: () => Injector,
@@ -2708,7 +2709,6 @@ __export(shared_exports, {
   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,
@@ -2718,60 +2718,67 @@ __export(shared_exports, {
   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: () => filter2,
-  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
 });
 
+// ../../node_modules/.pnpm/uid@2.0.2/node_modules/uid/dist/index.mjs
+var IDX = 256;
+var HEX = [];
+var SIZE = 256;
+var BUFFER;
+while (IDX--) HEX[IDX] = (IDX + 256).toString(16).substring(1);
+function uid(len) {
+  var i = 0, tmp = len || 11;
+  if (!BUFFER || IDX + tmp > SIZE * 2) {
+    for (BUFFER = "", IDX = 0; i < SIZE; i++) {
+      BUFFER += HEX[Math.random() * 256 | 0];
+    }
+  }
+  return BUFFER.substring(IDX, IDX++ + tmp);
+}
+
 // src/shared/store.ts
 var Store = class {
   constructor() {
@@ -2816,6 +2823,9 @@ var EXPRESS_ADAPTER_HOST = /* @__PURE__ */ Symbol("orca:express");
 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");
@@ -2830,6 +2840,8 @@ var HandlerParamType = /* @__PURE__ */ ((HandlerParamType2) => {
   HandlerParamType2["HEADERS"] = "HEADERS";
   HandlerParamType2["REQUEST"] = "REQUEST";
   HandlerParamType2["RESPONSE"] = "RESPONSE";
+  HandlerParamType2["FILE"] = "FILE";
+  HandlerParamType2["FILES"] = "FILES";
   return HandlerParamType2;
 })(HandlerParamType || {});
 var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
@@ -2855,6 +2867,13 @@ function Injectable() {
     return target;
   };
 }
+function mixin(mixinClass) {
+  Object.defineProperty(mixinClass, "name", {
+    value: uid(21)
+  });
+  Injectable()(mixinClass);
+  return mixinClass;
+}
 function Component(params = {}) {
   return function(target) {
     store.update("components", (current) => {
@@ -2871,7 +2890,7 @@ function Component(params = {}) {
     }
     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;
   };
 }
@@ -2915,6 +2934,18 @@ function Body(key2) {
 function Query(key2) {
   return getHandlerParamDecorator("QUERY" /* QUERY */, key2);
 }
+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, key2, descriptor) {
     Reflect.defineMetadata(HTTP_METHOD_KEY, httpMethod, target, key2);
@@ -2934,6 +2965,10 @@ function Sse(path) {
     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);
@@ -2972,6 +3007,61 @@ function parseSignatureSchemas(schemas, paramCount) {
   }
   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, key2, 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 {
@@ -3033,10 +3123,11 @@ var Compiler = class {
   }
   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);
@@ -3075,6 +3166,38 @@ var Compiler = class {
     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 parts2 = [];
+    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(",");
+      parts2.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(",");
+      parts2.push(`e:${exportTokens}`);
+    }
+    if (dynamicModule.controllers && dynamicModule.controllers.length > 0) {
+      const controllerNames = dynamicModule.controllers.map((c) => c.name).sort().join(",");
+      parts2.push(`c:${controllerNames}`);
+    }
+    if (dynamicModule.declarations && dynamicModule.declarations.length > 0) {
+      const declarationNames = dynamicModule.declarations.map((d) => d.name).sort().join(",");
+      parts2.push(`d:${declarationNames}`);
+    }
+    return parts2.length > 0 ? parts2.join("|") : null;
+  }
   validate(rootNode) {
     const errors = [];
     const allNodes = /* @__PURE__ */ new Map();
@@ -3171,14 +3294,23 @@ var Compiler = class {
     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) || [];
@@ -3253,9 +3385,10 @@ var Compiler = class {
 };
 
 // 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) => {
@@ -3263,14 +3396,20 @@ var Injector = class {
       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) {
@@ -3280,23 +3419,101 @@ var Injector = class {
         `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();
@@ -3378,14 +3595,14 @@ function v4(options, buf, offset) {
 var v4_default = v4;
 
 // src/shared/jsx/jsx-runtime.ts
-function jsx(type, config, maybeKey) {
-  const key2 = maybeKey !== void 0 ? maybeKey : config?.key ?? null;
+function jsx(type, config2, maybeKey) {
+  const key2 = maybeKey !== void 0 ? maybeKey : config2?.key ?? null;
   const props = {};
-  if (config) {
-    for (const propName in config) {
+  if (config2) {
+    for (const propName in config2) {
       if (propName === "key") continue;
       if (propName === "ref") continue;
-      props[propName] = config[propName];
+      props[propName] = config2[propName];
     }
   }
   if (props.children !== void 0) {
@@ -3522,14 +3739,14 @@ var StringRenderer = class {
     return "";
   }
   escapeHtml(text) {
-    const map2 = {
+    const map = {
       "&": "&amp;",
       "<": "&lt;",
       ">": "&gt;",
       '"': "&quot;",
       "'": "&#039;"
     };
-    return text.replace(/[&<>"']/g, (m) => map2[m]);
+    return text.replace(/[&<>"']/g, (m) => map[m]);
   }
 };
 
@@ -6149,7 +6366,7 @@ function encodeXML(str) {
   }
   return ret + str.substr(lastIdx);
 }
-function getEscaper(regex, map2) {
+function getEscaper(regex, map) {
   return function escape3(data) {
     let match;
     let lastIdx = 0;
@@ -6158,7 +6375,7 @@ function getEscaper(regex, map2) {
       if (lastIdx !== match.index) {
         result += data.substring(lastIdx, match.index);
       }
-      result += map2.get(match[0].charCodeAt(0));
+      result += map.get(match[0].charCodeAt(0));
       lastIdx = match.index + 1;
     }
     return result + data.substring(lastIdx);
@@ -7617,9 +7834,9 @@ function dispatch(event, listener) {
   return event._stopImmediatePropagationFlag;
 }
 function invokeListeners({ currentTarget, target }) {
-  const map2 = wm.get(currentTarget);
-  if (map2 && map2.has(this.type)) {
-    const listeners = map2.get(this.type);
+  const map = wm.get(currentTarget);
+  if (map && map.has(this.type)) {
+    const listeners = map.get(this.type);
     if (currentTarget === target) {
       this.eventPhase = this.AT_TARGET;
     } else {
@@ -7649,17 +7866,17 @@ var DOMEventTarget = class {
     return null;
   }
   addEventListener(type, listener, options) {
-    const map2 = wm.get(this);
-    if (!map2.has(type))
-      map2.set(type, /* @__PURE__ */ new Map());
-    map2.get(type).set(listener, options);
+    const map = wm.get(this);
+    if (!map.has(type))
+      map.set(type, /* @__PURE__ */ new Map());
+    map.get(type).set(listener, options);
   }
   removeEventListener(type, listener) {
-    const map2 = wm.get(this);
-    if (map2.has(type)) {
-      const listeners = map2.get(type);
+    const map = wm.get(this);
+    if (map.has(type)) {
+      const listeners = map.get(type);
       if (listeners.delete(listener) && !listeners.size)
-        map2.delete(type);
+        map.delete(type);
     }
   }
   dispatchEvent(event) {
@@ -8992,15 +9209,15 @@ var filters = {
       return (parent == null || !adapter2.isTag(parent)) && next(elem);
     };
   },
-  scope(next, rule, options, context) {
+  scope(next, rule, options, context2) {
     const { equals } = options;
-    if (!context || context.length === 0) {
+    if (!context2 || context2.length === 0) {
       return filters["root"](next, rule, options);
     }
-    if (context.length === 1) {
-      return (elem) => equals(context[0], elem) && next(elem);
+    if (context2.length === 1) {
+      return (elem) => equals(context2[0], elem) && next(elem);
     }
-    return (elem) => context.includes(elem) && next(elem);
+    return (elem) => context2.includes(elem) && next(elem);
   },
   hover: dynamicStatePseudo("isHovered"),
   visited: dynamicStatePseudo("isVisited"),
@@ -9149,8 +9366,8 @@ function copyOptions(options) {
     equals: options.equals
   };
 }
-var is = (next, token, options, context, compileToken2) => {
-  const func = compileToken2(token, copyOptions(options), context);
+var is = (next, token, options, context2, compileToken2) => {
+  const func = compileToken2(token, copyOptions(options), context2);
   return func === import_boolbase4.default.trueFunc ? next : func === import_boolbase4.default.falseFunc ? import_boolbase4.default.falseFunc : (elem) => func(elem) && next(elem);
 };
 var subselects = {
@@ -9160,28 +9377,28 @@ var subselects = {
    */
   matches: is,
   where: is,
-  not(next, token, options, context, compileToken2) {
-    const func = compileToken2(token, copyOptions(options), context);
+  not(next, token, options, context2, compileToken2) {
+    const func = compileToken2(token, copyOptions(options), context2);
     return func === import_boolbase4.default.falseFunc ? next : func === import_boolbase4.default.trueFunc ? import_boolbase4.default.falseFunc : (elem) => !func(elem) && next(elem);
   },
   has(next, subselect, options, _context, compileToken2) {
     const { adapter: adapter2 } = options;
     const opts = copyOptions(options);
     opts.relativeSelector = true;
-    const context = subselect.some((s) => s.some(isTraversal2)) ? (
+    const context2 = subselect.some((s) => s.some(isTraversal2)) ? (
       // Used as a placeholder. Will be replaced with the actual element.
       [PLACEHOLDER_ELEMENT]
     ) : void 0;
-    const compiled = compileToken2(subselect, opts, context);
+    const compiled = compileToken2(subselect, opts, context2);
     if (compiled === import_boolbase4.default.falseFunc)
       return import_boolbase4.default.falseFunc;
     const hasElement = ensureIsTag(compiled, adapter2);
-    if (context && compiled !== import_boolbase4.default.trueFunc) {
+    if (context2 && compiled !== import_boolbase4.default.trueFunc) {
       const { shouldTestNextSiblings = false } = compiled;
       return (elem) => {
         if (!next(elem))
           return false;
-        context[0] = elem;
+        context2[0] = elem;
         const childs = adapter2.getChildren(elem);
         const nextElements = shouldTestNextSiblings ? [...childs, ...getNextSiblings(elem, adapter2)] : childs;
         return adapter2.existsOne(hasElement, nextElements);
@@ -9192,14 +9409,14 @@ var subselects = {
 };
 
 // ../../node_modules/.pnpm/css-select@5.2.2/node_modules/css-select/lib/esm/pseudo-selectors/index.js
-function compilePseudoSelector(next, selector, options, context, compileToken2) {
+function compilePseudoSelector(next, selector, options, context2, compileToken2) {
   var _a4;
   const { name, data } = selector;
   if (Array.isArray(data)) {
     if (!(name in subselects)) {
       throw new Error(`Unknown pseudo-class :${name}(${data})`);
     }
-    return subselects[name](next, data, options, context, compileToken2);
+    return subselects[name](next, data, options, context2, compileToken2);
   }
   const userPseudo = (_a4 = options.pseudos) === null || _a4 === void 0 ? void 0 : _a4[name];
   const stringPseudo = typeof userPseudo === "string" ? userPseudo : aliases[name];
@@ -9208,14 +9425,14 @@ function compilePseudoSelector(next, selector, options, context, compileToken2)
       throw new Error(`Pseudo ${name} doesn't have any arguments`);
     }
     const alias = parse(stringPseudo);
-    return subselects["is"](next, alias, options, context, compileToken2);
+    return subselects["is"](next, alias, options, context2, compileToken2);
   }
   if (typeof userPseudo === "function") {
     verifyPseudoArgs(userPseudo, name, data, 1);
     return (elem) => userPseudo(elem, data) && next(elem);
   }
   if (name in filters) {
-    return filters[name](next, data, options, context);
+    return filters[name](next, data, options, context2);
   }
   if (name in pseudos) {
     const pseudo = pseudos[name];
@@ -9233,7 +9450,7 @@ function getElementParent(node, adapter2) {
   }
   return null;
 }
-function compileGeneralSelector(next, selector, options, context, compileToken2) {
+function compileGeneralSelector(next, selector, options, context2, compileToken2) {
   const { adapter: adapter2, equals } = options;
   switch (selector.type) {
     case SelectorType.PseudoElement: {
@@ -9252,7 +9469,7 @@ function compileGeneralSelector(next, selector, options, context, compileToken2)
       return attributeRules[selector.action](next, selector, options);
     }
     case SelectorType.Pseudo: {
-      return compilePseudoSelector(next, selector, options, context, compileToken2);
+      return compilePseudoSelector(next, selector, options, context2, compileToken2);
     }
     // Tags
     case SelectorType.Tag: {
@@ -9360,13 +9577,13 @@ function compileGeneralSelector(next, selector, options, context, compileToken2)
 }
 
 // ../../node_modules/.pnpm/css-select@5.2.2/node_modules/css-select/lib/esm/compile.js
-function compile2(selector, options, context) {
-  const next = compileUnsafe(selector, options, context);
+function compile2(selector, options, context2) {
+  const next = compileUnsafe(selector, options, context2);
   return ensureIsTag(next, options.adapter);
 }
-function compileUnsafe(selector, options, context) {
+function compileUnsafe(selector, options, context2) {
   const token = typeof selector === "string" ? parse(selector) : selector;
-  return compileToken(token, options, context);
+  return compileToken(token, options, context2);
 }
 function includesScopePseudo(t) {
   return t.type === SelectorType.Pseudo && (t.name === "scope" || Array.isArray(t.data) && t.data.some((data) => data.some(includesScopePseudo)));
@@ -9380,8 +9597,8 @@ var SCOPE_TOKEN = {
   name: "scope",
   data: null
 };
-function absolutize(token, { adapter: adapter2 }, context) {
-  const hasContext = !!(context === null || context === void 0 ? void 0 : context.every((e) => {
+function absolutize(token, { adapter: adapter2 }, context2) {
+  const hasContext = !!(context2 === null || context2 === void 0 ? void 0 : context2.every((e) => {
     const parent = adapter2.isTag(e) && adapter2.getParent(e);
     return e === PLACEHOLDER_ELEMENT || parent && adapter2.isTag(parent);
   }));
@@ -9395,12 +9612,12 @@ function absolutize(token, { adapter: adapter2 }, context) {
     t.unshift(SCOPE_TOKEN);
   }
 }
-function compileToken(token, options, context) {
+function compileToken(token, options, context2) {
   var _a4;
   token.forEach(sortByProcedure);
-  context = (_a4 = options.context) !== null && _a4 !== void 0 ? _a4 : context;
-  const isArrayContext = Array.isArray(context);
-  const finalContext = context && (Array.isArray(context) ? context : [context]);
+  context2 = (_a4 = options.context) !== null && _a4 !== void 0 ? _a4 : context2;
+  const isArrayContext = Array.isArray(context2);
+  const finalContext = context2 && (Array.isArray(context2) ? context2 : [context2]);
   if (options.relativeSelector !== false) {
     absolutize(token, options, finalContext);
   } else if (token.some((t) => t.length > 0 && isTraversal2(t[0]))) {
@@ -9422,9 +9639,9 @@ function compileToken(token, options, context) {
   query2.shouldTestNextSiblings = shouldTestNextSiblings;
   return query2;
 }
-function compileRules(rules, options, context) {
+function compileRules(rules, options, context2) {
   var _a4;
-  return rules.reduce((previous, rule) => previous === import_boolbase5.default.falseFunc ? import_boolbase5.default.falseFunc : compileGeneralSelector(previous, rule, options, context, compileToken), (_a4 = options.rootFunc) !== null && _a4 !== void 0 ? _a4 : import_boolbase5.default.trueFunc);
+  return rules.reduce((previous, rule) => previous === import_boolbase5.default.falseFunc ? import_boolbase5.default.falseFunc : compileGeneralSelector(previous, rule, options, context2, compileToken), (_a4 = options.rootFunc) !== null && _a4 !== void 0 ? _a4 : import_boolbase5.default.trueFunc);
 }
 function reduceRules(a, b) {
   if (b === import_boolbase5.default.falseFunc || a === import_boolbase5.default.trueFunc) {
@@ -9452,9 +9669,9 @@ function convertOptionFormats(options) {
   return opts;
 }
 function wrapCompile(func) {
-  return function addAdapter(selector, options, context) {
+  return function addAdapter(selector, options, context2) {
     const opts = convertOptionFormats(options);
-    return func(selector, opts, context);
+    return func(selector, opts, context2);
   };
 }
 var compile3 = wrapCompile(compile2);
@@ -13229,7 +13446,7 @@ var StreamRenderer = class {
         );
       }
     }
-    const instance = componentInjector.resolve(ComponentClass);
+    const instance = componentInjector.resolveSync(ComponentClass);
     const mergedProps = Object.create(
       Object.getPrototypeOf(instance.props || {})
     );
@@ -13597,86 +13814,7 @@ function untracked(fn) {
   }
 }
 
-// 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 value2 of iterable) {
-        observer.next(value2);
-      }
-      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((value2) => observer.next(value2));
-      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) => {
@@ -13688,495 +13826,817 @@ function toSignal(obs, instance) {
   ];
   return sig;
 }
-function isObservable(value2) {
-  return value2 && value2.__isObservable === true;
-}
-function map(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value2) => {
-          try {
-            observer.next(fn(value2));
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function filter2(predicate) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value2) => {
-          try {
-            if (predicate(value2)) {
-              observer.next(value2);
-            }
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
+
+// src/shared/component.ts
+var OrcaComponent = class {
+  constructor() {
+    this.__cleanup = [];
+  }
+  onInit() {
+  }
+  onDestroy() {
+    this.__cleanup.forEach((cb) => cb());
+  }
+  pushDrop(fn) {
+    this.__cleanup.push(fn);
+  }
+};
+
+// ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
   };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
-function tap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value2) => {
-          try {
-            fn(value2);
-            observer.next(value2);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
   };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-function take(count) {
-  return (source) => {
-    return new Observable((observer) => {
-      let taken = 0;
-      const subscription = source.subscribe(
-        (value2) => {
-          if (taken < count) {
-            observer.next(value2);
-            taken++;
-            if (taken === count) {
-              observer.complete?.();
-              subscription.unsubscribe();
-            }
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
 }
-function skip(count) {
-  return (source) => {
-    return new Observable((observer) => {
-      let skipped = 0;
-      const subscription = source.subscribe(
-        (value2) => {
-          if (skipped < count) {
-            skipped++;
-          } else {
-            observer.next(value2);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
 }
-function debounceTime(ms) {
-  return (source) => {
-    return new Observable((observer) => {
-      let timeoutId;
-      const subscription = source.subscribe(
-        (value2) => {
-          clearTimeout(timeoutId);
-          timeoutId = setTimeout(() => {
-            observer.next(value2);
-          }, ms);
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => {
-        clearTimeout(timeoutId);
-        subscription.unsubscribe();
-      };
-    });
-  };
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function isFunction(value2) {
+  return typeof value2 === "function";
 }
-function throttleTime(ms) {
-  return (source) => {
-    return new Observable((observer) => {
-      let lastEmit = 0;
-      const subscription = source.subscribe(
-        (value2) => {
-          const now = Date.now();
-          if (now - lastEmit >= ms) {
-            lastEmit = now;
-            observer.next(value2);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
   };
-}
-function distinctUntilChanged(compare) {
-  return (source) => {
-    return new Observable((observer) => {
-      let hasLast = false;
-      let last;
-      const subscription = source.subscribe(
-        (value2) => {
-          const isDistinct = !hasLast || (compare ? !compare(last, value2) : last !== value2);
-          if (isDistinct) {
-            hasLast = true;
-            last = value2;
-            observer.next(value2);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
   };
-}
-function switchMap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      let innerSubscription = null;
-      const outerSubscription = source.subscribe(
-        (value2) => {
-          if (innerSubscription) {
-            innerSubscription.unsubscribe();
-          }
+});
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscription.js
+var Subscription = (function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a4, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
           try {
-            const innerObservable = fn(value2);
-            innerSubscription = innerObservable.subscribe(
-              (innerValue) => observer.next(innerValue),
-              (err) => observer.error?.(err)
-            );
-          } catch (err) {
-            observer.error?.(err);
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a4 = _parentage_1.return)) _a4.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
           }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => {
-        if (innerSubscription) {
-          innerSubscription.unsubscribe();
+        } else {
+          _parentage.remove(this);
         }
-        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?.();
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
         }
-      };
-      const outerSubscription = source.subscribe(
-        (value2) => {
-          try {
-            const innerObservable = fn(value2);
-            activeCount++;
-            const innerSub = innerObservable.subscribe(
-              (innerValue) => observer.next(innerValue),
-              (err) => observer.error?.(err),
-              () => {
-                activeCount--;
-                checkComplete();
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
               }
-            );
-            innerSubscriptions.push(innerSub);
-          } catch (err) {
-            observer.error?.(err);
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
           }
-        },
-        (err) => observer.error?.(err),
-        () => {
-          outerComplete = true;
-          checkComplete();
         }
-      );
-      return () => {
-        innerSubscriptions.forEach((sub) => sub.unsubscribe());
-        outerSubscription.unsubscribe();
-      };
-    });
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
   };
-}
-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?.();
+  Subscription2.prototype.add = function(teardown) {
+    var _a4;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
           }
-          return;
+          teardown._addParent(this);
         }
-        isProcessing = true;
-        const value2 = queue.shift();
-        try {
-          const innerObservable = fn(value2);
-          innerSubscription = innerObservable.subscribe(
-            (innerValue) => observer.next(innerValue),
-            (err) => observer.error?.(err),
-            () => {
-              isProcessing = false;
-              processNext();
-            }
-          );
-        } catch (err) {
-          observer.error?.(err);
-        }
-      };
-      const outerSubscription = source.subscribe(
-        (value2) => {
-          queue.push(value2);
-          processNext();
-        },
-        (err) => observer.error?.(err),
-        () => {
-          outerComplete = true;
-          if (queue.length === 0 && !isProcessing) {
-            observer.complete?.();
-          }
-        }
-      );
-      return () => {
-        if (innerSubscription) {
-          innerSubscription.unsubscribe();
-        }
-        outerSubscription.unsubscribe();
-      };
-    });
+        (this._finalizers = (_a4 = this._finalizers) !== null && _a4 !== void 0 ? _a4 : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
   };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = (function() {
+    var empty2 = new Subscription2();
+    empty2.closed = true;
+    return empty2;
+  })();
+  return Subscription2;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value2) {
+  return value2 instanceof Subscription || value2 && "closed" in value2 && isFunction(value2.remove) && isFunction(value2.add) && isFunction(value2.unsubscribe);
 }
-function catchError(handler4) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value2) => observer.next(value2),
-        (err) => {
-          try {
-            const fallback = handler4(err);
-            const fallbackSub = fallback.subscribe(
-              (value2) => observer.next(value2),
-              (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 execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/config.js
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
+var timeoutProvider = {
+  setTimeout: function(handler4, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = timeoutProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout.apply(delegate, __spreadArray([handler4, timeout], __read(args)));
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler4, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    var onUnhandledError = config.onUnhandledError;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/noop.js
+function noop() {
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = (function() {
+  return createNotification("C", void 0, void 0);
+})();
+function errorNotification(error) {
+  return createNotification("E", void 0, error);
+}
+function nextNotification(value2) {
+  return createNotification("N", value2, void 0);
+}
+function createNotification(kind, value2, error) {
+  return {
+    kind,
+    value: value2,
+    error
+  };
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    var isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      var _a4 = context, errorThrown = _a4.errorThrown, error = _a4.error;
+      context = null;
+      if (errorThrown) {
+        throw error;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var Subscriber = (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value2) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value2), this);
+    } else {
+      this._next(value2);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value2) {
+    this.destination.next(value2);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+})(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = (function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value2) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value2);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+})();
+var SafeSubscriber = (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
       };
-    });
+    } else {
+      var context_1;
+      if (_this && config.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function() {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+})(Subscriber);
+function handleUnhandledError(error) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    captureError(error);
+  } else {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+  var onStoppedNotification = config.onStoppedNotification;
+  onStoppedNotification && timeoutProvider.setTimeout(function() {
+    return onStoppedNotification(notification, subscriber);
+  });
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/symbol/observable.js
+var observable = (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/identity.js
+function identity(x) {
+  return x;
+}
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
   };
 }
-function startWith(...values) {
-  return (source) => {
-    return new Observable((observer) => {
-      values.forEach((value2) => observer.next(value2));
-      const subscription = source.subscribe(
-        (value2) => observer.next(value2),
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Observable.js
+var Observable = (function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a4 = _this, operator = _a4.operator, source = _a4.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
     });
+    return subscriber;
   };
-}
-function scan(accumulator, seed) {
-  return (source) => {
-    return new Observable((observer) => {
-      let acc = seed;
-      const subscription = source.subscribe(
-        (value2) => {
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value2) {
           try {
-            acc = accumulator(acc, value2);
-            observer.next(acc);
+            next(value2);
           } catch (err) {
-            observer.error?.(err);
+            reject(err);
+            subscriber.unsubscribe();
           }
         },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
     });
   };
-}
-function reduce(accumulator, seed) {
-  return (source) => {
-    return new Observable((observer) => {
-      let acc = seed;
-      const subscription = source.subscribe(
-        (value2) => {
-          try {
-            acc = accumulator(acc, value2);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => {
-          observer.next(acc);
-          observer.complete?.();
-        }
-      );
-      return () => subscription.unsubscribe();
+  Observable2.prototype._subscribe = function(subscriber) {
+    var _a4;
+    return (_a4 = this.source) === null || _a4 === void 0 ? void 0 : _a4.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var value2;
+      _this.subscribe(function(x) {
+        return value2 = x;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve(value2);
+      });
     });
   };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  var _a4;
+  return (_a4 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a4 !== void 0 ? _a4 : Promise;
+}
+function isObserver(value2) {
+  return value2 && isFunction(value2.next) && isFunction(value2.error) && isFunction(value2.complete);
+}
+function isSubscriber(value2) {
+  return value2 && value2 instanceof Subscriber || isObserver(value2) && isSubscription(value2);
 }
 
-// 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: () => {
-      } };
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subject.js
+var Subject = (function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
     }
-    const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-    this.subscribers.add(observer);
-    return {
-      unsubscribe: () => {
-        this.subscribers.delete(observer);
-      }
-    };
-  }
-  next(value2) {
-    if (this._isCompleted || this._hasError) return;
-    const currentSubscribers = Array.from(this.subscribers);
-    currentSubscribers.forEach((observer) => {
-      if (this.subscribers.has(observer)) {
+  };
+  Subject2.prototype.next = function(value2) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a4;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
         try {
-          observer.next(value2);
-        } catch (err) {
-          console.error("Error in observer:", err);
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value2);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a4 = _b.return)) _a4.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
         }
       }
     });
-  }
-  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);
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(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(value2) {
-    this._value = value2;
-    super.next(value2);
-  }
-  subscribe(observerOrNext, error, complete) {
-    const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-    if (this._hasError) {
-      observer.error?.(this._thrownError);
-      return { unsubscribe: () => {
-      } };
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a4;
+      return ((_a4 = this.observers) === null || _a4 === void 0 ? void 0 : _a4.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this;
+    var _a4 = this, hasError = _a4.hasError, isStopped = _a4.isStopped, observers = _a4.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a4 = this, hasError = _a4.hasError, thrownError = _a4.thrownError, isStopped = _a4.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
     }
-    if (this._isCompleted) {
-      observer.complete?.();
-      return { unsubscribe: () => {
-      } };
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+})(Observable);
+var AnonymousSubject = (function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value2) {
+    var _a4, _b;
+    (_b = (_a4 = this.destination) === null || _a4 === void 0 ? void 0 : _a4.next) === null || _b === void 0 ? void 0 : _b.call(_a4, value2);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a4, _b;
+    (_b = (_a4 = this.destination) === null || _a4 === void 0 ? void 0 : _a4.error) === null || _b === void 0 ? void 0 : _b.call(_a4, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a4, _b;
+    (_b = (_a4 = this.destination) === null || _a4 === void 0 ? void 0 : _a4.complete) === null || _b === void 0 ? void 0 : _b.call(_a4);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var _a4, _b;
+    return (_b = (_a4 = this.source) === null || _a4 === void 0 ? void 0 : _a4.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+})(Subject);
+
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js
+var BehaviorSubject = (function(_super) {
+  __extends(BehaviorSubject2, _super);
+  function BehaviorSubject2(_value) {
+    var _this = _super.call(this) || this;
+    _this._value = _value;
+    return _this;
+  }
+  Object.defineProperty(BehaviorSubject2.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: false,
+    configurable: true
+  });
+  BehaviorSubject2.prototype._subscribe = function(subscriber) {
+    var subscription = _super.prototype._subscribe.call(this, subscriber);
+    !subscription.closed && subscriber.next(this._value);
+    return subscription;
+  };
+  BehaviorSubject2.prototype.getValue = function() {
+    var _a4 = this, hasError = _a4.hasError, thrownError = _a4.thrownError, _value = _a4._value;
+    if (hasError) {
+      throw thrownError;
     }
-    observer.next(this._value);
-    return super.subscribe(observer);
-  }
-};
-
-// src/shared/component.ts
-var OrcaComponent = class {
-  constructor() {
-    this.__cleanup = [];
-  }
-  onInit() {
-  }
-  onDestroy() {
-    this.__cleanup.forEach((cb) => cb());
-  }
-  pushDrop(fn) {
-    this.__cleanup.push(fn);
-  }
-};
+    this._throwIfClosed();
+    return _value;
+  };
+  BehaviorSubject2.prototype.next = function(value2) {
+    _super.prototype.next.call(this, this._value = value2);
+  };
+  return BehaviorSubject2;
+})(Subject);
 
 // src/shared/module_libs/http_client/module.ts
 var __decorate = function(decorators, target, key2, desc) {
@@ -14626,9 +15086,21 @@ var OSC = class _OSC {
       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()`);
       }
@@ -14642,11 +15114,6 @@ var OSC = class _OSC {
   }
 };
 
-// src/shared/macros/index.ts
-function assert$(context) {
-  return context?.factory.createStringLiteral("assert");
-}
-
 // src/shared/providers/actor.ts
 var BaseActor = class {
   constructor() {
@@ -14997,9 +15464,9 @@ var protocol = 4;
 
 // ../../node_modules/.pnpm/@socket.io+component-emitter@3.1.2/node_modules/@socket.io/component-emitter/lib/esm/index.js
 function Emitter(obj) {
-  if (obj) return mixin(obj);
+  if (obj) return mixin2(obj);
 }
-function mixin(obj) {
+function mixin2(obj) {
   for (var key2 in Emitter.prototype) {
     obj[key2] = Emitter.prototype[key2];
   }
@@ -15161,10 +15628,10 @@ function decode2(qs) {
 
 // ../../node_modules/.pnpm/engine.io-client@6.6.4/node_modules/engine.io-client/build/esm/transport.js
 var TransportError = class extends Error {
-  constructor(reason, description, context) {
+  constructor(reason, description, context2) {
     super(reason);
     this.description = description;
-    this.context = context;
+    this.context = context2;
     this.type = "TransportError";
   }
 };
@@ -15193,8 +15660,8 @@ var Transport = class extends Emitter {
    * @return {Transport} for chaining
    * @protected
    */
-  onError(reason, description, context) {
-    super.emitReserved("error", new TransportError(reason, description, context));
+  onError(reason, description, context2) {
+    super.emitReserved("error", new TransportError(reason, description, context2));
     return this;
   }
   /**
@@ -15464,8 +15931,8 @@ var BaseXHR = class extends Polling {
       data
     });
     req.on("success", fn);
-    req.on("error", (xhrStatus, context) => {
-      this.onError("xhr post error", xhrStatus, context);
+    req.on("error", (xhrStatus, context2) => {
+      this.onError("xhr post error", xhrStatus, context2);
     });
   }
   /**
@@ -15476,8 +15943,8 @@ var BaseXHR = class extends Polling {
   doPoll() {
     const req = this.request();
     req.on("data", this.onData.bind(this));
-    req.on("error", (xhrStatus, context) => {
-      this.onError("xhr poll error", xhrStatus, context);
+    req.on("error", (xhrStatus, context2) => {
+      this.onError("xhr poll error", xhrStatus, context2);
     });
     this.pollXhr = req;
   }
@@ -18184,30 +18651,39 @@ var Navigate = class Navigate2 {
     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;
+      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 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 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);
     });
   }
@@ -18221,75 +18697,77 @@ var Navigate = class Navigate2 {
   }
   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 url2 = this.oscUrl;
     if (route && route !== "/") {
-      url2 = `${this.oscUrl}?c=${encodeURIComponent(route)}`;
+      const separator = url2.includes("?") ? "&" : "?";
+      url2 = `${url2}${separator}c=${encodeURIComponent(route)}`;
     }
     return http.post(url2, {
       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()) {
@@ -18300,17 +18778,22 @@ var Navigate = class Navigate2 {
     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();
   }
@@ -18335,42 +18818,87 @@ var RouterOutlet = class RouterOutlet2 extends OrcaComponent {
   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);
+      }
+    }
+    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 (this.activeStreamSubscription) {
-      this.activeStreamSubscription.unsubscribe();
-      this.activeStreamSubscription = null;
+    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);
@@ -18381,11 +18909,14 @@ var RouterOutlet = class RouterOutlet2 extends OrcaComponent {
       }
     }, (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";
@@ -18445,7 +18976,7 @@ var InjectorConfigurationService = class {
   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));
     });
   }
 };
@@ -18457,8 +18988,8 @@ var BootstrapService = class {
     }
     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);
@@ -18472,14 +19003,14 @@ var BrowserFactory = class {
    * @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);
   }
 };
 
@@ -18611,7 +19142,7 @@ function createComponent(ComponentClass, props = {}, parentComponent) {
   }
   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}`);
@@ -18733,7 +19264,6 @@ export {
   ActorModule,
   BOOTSTRAP,
   BOOTSTRAP_VNODE,
-  BehaviorSubject,
   Body,
   BrowserFactory,
   COMPONENT,
@@ -18753,6 +19283,7 @@ export {
   EXPORTS_KEY,
   EXPRESS_ADAPTER_HOST,
   Fragment,
+  GUARDS_KEY,
   Get,
   HTTP_METHOD_KEY,
   HandlerParamType,
@@ -18762,6 +19293,7 @@ export {
   IMPORTS_KEY,
   INJECTABLE,
   INJECT_TOKENS_KEY,
+  INTERCEPTORS_KEY,
   Inject,
   Injectable,
   Injector,
@@ -18773,7 +19305,6 @@ export {
   ORCA_ELEMENT_TYPE,
   ORCA_FRAGMENT_TYPE,
   OSC,
-  Observable,
   OrcaComponent,
   PARAMS_META_KEY,
   PATH_KEY,
@@ -18783,60 +19314,51 @@ export {
   Post,
   ProviderNormalizer,
   Query,
+  REQUEST_CONTEXT,
+  Req,
+  Res,
   RouterModule,
   RouterOutlet,
   SIGNATURE_METADATA_KEY,
   SSE_ROUTE,
+  SetMetadata,
+  Shared,
   Signature,
   Sse,
-  Subject,
   Subscribe,
-  assert$,
+  UploadedFile,
+  UploadedFiles,
+  UseGuards,
+  UseInterceptors,
+  applyDecorators,
   batch,
   browser_exports as browser,
-  catchError,
   collectAllProvidersFromNode,
   computed,
-  concatMap,
   createComponent,
   createRoot,
-  debounceTime,
-  distinctUntilChanged,
   effect,
-  filter2 as filter,
-  from,
   getCurrentInjector,
+  getGuards,
+  getInterceptors,
   getSignatureMetadata,
   hasSignature,
   insert2 as insert,
-  interval,
   isClassComponent,
   isFragment,
   isIntrinsicElement,
-  isObservable,
   isSignal,
   jsx,
   jsxs,
-  map,
-  mergeMap,
-  observable,
-  of,
+  mixin,
   parseSignatureSchemas,
-  reduce,
-  scan,
   setCurrentInjector,
   shared_exports as shared,
   signal,
-  skip,
   spread,
-  startWith,
   style,
-  switchMap,
   symbolValueReplacer,
   symbolValueReviver,
-  take,
-  tap,
-  throttleTime,
   toSignal,
   untracked
 };