@kithinji/orca 1.0.26 → 1.0.29

package/dist/node/index.mjs

@@ -13,7 +13,6 @@ __export(shared_exports, {
   BOOTSTRAP: () => BOOTSTRAP,
   BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
   BaseActor: () => BaseActor,
-  BehaviorSubject: () => BehaviorSubject,
   Body: () => Body,
   COMPONENT: () => COMPONENT,
   COMPONENT_DEPS: () => COMPONENT_DEPS,
@@ -32,6 +31,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,
@@ -41,6 +41,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,
@@ -51,7 +52,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,
@@ -61,60 +61,54 @@ __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: () => filter,
-  from: () => from,
   getCurrentInjector: () => getCurrentInjector,
+  getGuards: () => getGuards,
+  getInterceptors: () => getInterceptors,
   getSignatureMetadata: () => getSignatureMetadata,
   hasSignature: () => hasSignature,
-  interval: () => interval,
   isClassComponent: () => isClassComponent,
   isFragment: () => isFragment,
   isIntrinsicElement: () => isIntrinsicElement,
-  isObservable: () => isObservable,
   isSignal: () => isSignal,
   jsx: () => jsx,
   jsxs: () => jsxs,
-  map: () => map,
-  mergeMap: () => mergeMap,
-  observable: () => observable,
-  of: () => of,
+  mixin: () => mixin,
   parseSignatureSchemas: () => parseSignatureSchemas,
-  reduce: () => reduce,
-  scan: () => scan,
   setCurrentInjector: () => setCurrentInjector,
   signal: () => signal,
-  skip: () => skip,
-  startWith: () => startWith,
   store: () => store,
-  switchMap: () => switchMap,
   symbolValueReplacer: () => symbolValueReplacer,
   symbolValueReviver: () => symbolValueReviver,
-  take: () => take,
-  tap: () => tap,
-  throttleTime: () => throttleTime,
   toSignal: () => toSignal,
   untracked: () => untracked
 });
 
+// src/shared/decorators.ts
+import { uid } from "uid";
+
 // src/shared/store.ts
 var Store = class {
   constructor() {
@@ -159,6 +153,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");
@@ -173,6 +170,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) => {
@@ -198,6 +197,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) => {
@@ -214,7 +220,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;
   };
 }
@@ -258,6 +264,18 @@ function Body(key) {
 function Query(key) {
   return getHandlerParamDecorator("QUERY" /* QUERY */, key);
 }
+function UploadedFile() {
+  return getHandlerParamDecorator("FILE" /* FILE */);
+}
+function UploadedFiles() {
+  return getHandlerParamDecorator("FILES" /* FILES */);
+}
+function Req() {
+  return getHandlerParamDecorator("REQUEST" /* REQUEST */);
+}
+function Res() {
+  return getHandlerParamDecorator("RESPONSE" /* RESPONSE */);
+}
 function getRouteDecorator(httpMethod, path2) {
   return function(target, key, descriptor) {
     Reflect.defineMetadata(HTTP_METHOD_KEY, httpMethod, target, key);
@@ -277,6 +295,10 @@ function Sse(path2) {
     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);
@@ -315,6 +337,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, key, descriptor) => {
+    if (descriptor) {
+      Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(metadataKey, metadataValue, target);
+    return target;
+  };
+  decoratorFactory.KEY = metadataKey;
+  return decoratorFactory;
+};
+function applyDecorators(...decorators) {
+  return (target, propertyKey, descriptor) => {
+    for (const decorator of decorators) {
+      if (target instanceof Function && !descriptor) {
+        decorator(target);
+        continue;
+      }
+      decorator(target, propertyKey, descriptor);
+    }
+  };
+}
 
 // src/shared/module/node.ts
 var ProviderNormalizer = class {
@@ -376,10 +453,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 Node(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 Node(nodeKey);
+    this.nodes.set(nodeKey, node);
     const imports = this.getImports(moduleOrDynamic);
     node.setChildren(imports.map((imp) => this.createNode(imp)));
     const providers = this.getProviders(moduleOrDynamic);
@@ -418,6 +496,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 parts = [];
+    if (dynamicModule.providers && dynamicModule.providers.length > 0) {
+      const providerTokens = dynamicModule.providers.map((p) => this.getProviderToken(p)).map((t) => typeof t === "function" ? t.name : String(t)).sort().join(",");
+      parts.push(`p:${providerTokens}`);
+    }
+    if (dynamicModule.exports && dynamicModule.exports.length > 0) {
+      const exportTokens = dynamicModule.exports.map((t) => typeof t === "function" ? t.name : String(t)).sort().join(",");
+      parts.push(`e:${exportTokens}`);
+    }
+    if (dynamicModule.controllers && dynamicModule.controllers.length > 0) {
+      const controllerNames = dynamicModule.controllers.map((c) => c.name).sort().join(",");
+      parts.push(`c:${controllerNames}`);
+    }
+    if (dynamicModule.declarations && dynamicModule.declarations.length > 0) {
+      const declarationNames = dynamicModule.declarations.map((d) => d.name).sort().join(",");
+      parts.push(`d:${declarationNames}`);
+    }
+    return parts.length > 0 ? parts.join("|") : null;
+  }
   validate(rootNode) {
     const errors = [];
     const allNodes = /* @__PURE__ */ new Map();
@@ -514,14 +624,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) || [];
@@ -596,9 +715,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) => {
@@ -606,14 +726,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) {
@@ -623,23 +749,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();
@@ -811,14 +1015,14 @@ var StringRenderer = class {
     return "";
   }
   escapeHtml(text) {
-    const map2 = {
+    const map = {
       "&": "&",
       "<": "&lt;",
       ">": "&gt;",
       '"': "&quot;",
       "'": "&#039;"
     };
-    return text.replace(/[&<>"']/g, (m) => map2[m]);
+    return text.replace(/[&<>"']/g, (m) => map[m]);
   }
 };
 
@@ -932,7 +1136,7 @@ var StreamRenderer = class {
         );
       }
     }
-    const instance = componentInjector.resolve(ComponentClass);
+    const instance = componentInjector.resolveSync(ComponentClass);
     const mergedProps = Object.create(
       Object.getPrototypeOf(instance.props || {})
     );
@@ -1300,86 +1504,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 value of iterable) {
-        observer.next(value);
-      }
-      observer.complete?.();
-    } catch (err) {
-      observer.error?.(err);
-    }
-  });
-}
-function interval(ms) {
-  return new Observable((observer) => {
-    let count = 0;
-    const id = setInterval(() => {
-      observer.next(count++);
-    }, ms);
-    return () => clearInterval(id);
-  });
-}
-function of(...values) {
-  return new Observable((observer) => {
-    try {
-      values.forEach((value) => observer.next(value));
-      observer.complete?.();
-    } catch (err) {
-      observer.error?.(err);
-    }
-  });
-}
-function observable(producer) {
-  return new Observable(producer);
-}
+// src/shared/signal/utils.ts
 function toSignal(obs, instance) {
   const sig = signal(void 0);
   const subst = obs.subscribe((val) => {
@@ -1391,480 +1516,6 @@ function toSignal(obs, instance) {
   ];
   return sig;
 }
-function isObservable(value) {
-  return value && value.__isObservable === true;
-}
-function map(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value) => {
-          try {
-            observer.next(fn(value));
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function filter(predicate) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value) => {
-          try {
-            if (predicate(value)) {
-              observer.next(value);
-            }
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function tap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value) => {
-          try {
-            fn(value);
-            observer.next(value);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function take(count) {
-  return (source) => {
-    return new Observable((observer) => {
-      let taken = 0;
-      const subscription = source.subscribe(
-        (value) => {
-          if (taken < count) {
-            observer.next(value);
-            taken++;
-            if (taken === count) {
-              observer.complete?.();
-              subscription.unsubscribe();
-            }
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function skip(count) {
-  return (source) => {
-    return new Observable((observer) => {
-      let skipped = 0;
-      const subscription = source.subscribe(
-        (value) => {
-          if (skipped < count) {
-            skipped++;
-          } else {
-            observer.next(value);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function debounceTime(ms) {
-  return (source) => {
-    return new Observable((observer) => {
-      let timeoutId;
-      const subscription = source.subscribe(
-        (value) => {
-          clearTimeout(timeoutId);
-          timeoutId = setTimeout(() => {
-            observer.next(value);
-          }, ms);
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => {
-        clearTimeout(timeoutId);
-        subscription.unsubscribe();
-      };
-    });
-  };
-}
-function throttleTime(ms) {
-  return (source) => {
-    return new Observable((observer) => {
-      let lastEmit = 0;
-      const subscription = source.subscribe(
-        (value) => {
-          const now = Date.now();
-          if (now - lastEmit >= ms) {
-            lastEmit = now;
-            observer.next(value);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function distinctUntilChanged(compare) {
-  return (source) => {
-    return new Observable((observer) => {
-      let hasLast = false;
-      let last;
-      const subscription = source.subscribe(
-        (value) => {
-          const isDistinct = !hasLast || (compare ? !compare(last, value) : last !== value);
-          if (isDistinct) {
-            hasLast = true;
-            last = value;
-            observer.next(value);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function switchMap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      let innerSubscription = null;
-      const outerSubscription = source.subscribe(
-        (value) => {
-          if (innerSubscription) {
-            innerSubscription.unsubscribe();
-          }
-          try {
-            const innerObservable = fn(value);
-            innerSubscription = innerObservable.subscribe(
-              (innerValue) => observer.next(innerValue),
-              (err) => observer.error?.(err)
-            );
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => {
-        if (innerSubscription) {
-          innerSubscription.unsubscribe();
-        }
-        outerSubscription.unsubscribe();
-      };
-    });
-  };
-}
-function mergeMap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const innerSubscriptions = [];
-      let outerComplete = false;
-      let activeCount = 0;
-      const checkComplete = () => {
-        if (outerComplete && activeCount === 0) {
-          observer.complete?.();
-        }
-      };
-      const outerSubscription = source.subscribe(
-        (value) => {
-          try {
-            const innerObservable = fn(value);
-            activeCount++;
-            const innerSub = innerObservable.subscribe(
-              (innerValue) => observer.next(innerValue),
-              (err) => observer.error?.(err),
-              () => {
-                activeCount--;
-                checkComplete();
-              }
-            );
-            innerSubscriptions.push(innerSub);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => {
-          outerComplete = true;
-          checkComplete();
-        }
-      );
-      return () => {
-        innerSubscriptions.forEach((sub) => sub.unsubscribe());
-        outerSubscription.unsubscribe();
-      };
-    });
-  };
-}
-function concatMap(fn) {
-  return (source) => {
-    return new Observable((observer) => {
-      const queue = [];
-      let innerSubscription = null;
-      let outerComplete = false;
-      let isProcessing = false;
-      const processNext = () => {
-        if (isProcessing || queue.length === 0) {
-          if (outerComplete && queue.length === 0) {
-            observer.complete?.();
-          }
-          return;
-        }
-        isProcessing = true;
-        const value = queue.shift();
-        try {
-          const innerObservable = fn(value);
-          innerSubscription = innerObservable.subscribe(
-            (innerValue) => observer.next(innerValue),
-            (err) => observer.error?.(err),
-            () => {
-              isProcessing = false;
-              processNext();
-            }
-          );
-        } catch (err) {
-          observer.error?.(err);
-        }
-      };
-      const outerSubscription = source.subscribe(
-        (value) => {
-          queue.push(value);
-          processNext();
-        },
-        (err) => observer.error?.(err),
-        () => {
-          outerComplete = true;
-          if (queue.length === 0 && !isProcessing) {
-            observer.complete?.();
-          }
-        }
-      );
-      return () => {
-        if (innerSubscription) {
-          innerSubscription.unsubscribe();
-        }
-        outerSubscription.unsubscribe();
-      };
-    });
-  };
-}
-function catchError(handler) {
-  return (source) => {
-    return new Observable((observer) => {
-      const subscription = source.subscribe(
-        (value) => observer.next(value),
-        (err) => {
-          try {
-            const fallback = handler(err);
-            const fallbackSub = fallback.subscribe(
-              (value) => observer.next(value),
-              (e) => observer.error?.(e),
-              () => observer.complete?.()
-            );
-            subscription.__fallback = fallbackSub;
-          } catch (e) {
-            observer.error?.(e);
-          }
-        },
-        () => observer.complete?.()
-      );
-      return () => {
-        if (subscription.__fallback) {
-          subscription.__fallback.unsubscribe();
-        }
-        subscription.unsubscribe();
-      };
-    });
-  };
-}
-function startWith(...values) {
-  return (source) => {
-    return new Observable((observer) => {
-      values.forEach((value) => observer.next(value));
-      const subscription = source.subscribe(
-        (value) => observer.next(value),
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function scan(accumulator, seed) {
-  return (source) => {
-    return new Observable((observer) => {
-      let acc = seed;
-      const subscription = source.subscribe(
-        (value) => {
-          try {
-            acc = accumulator(acc, value);
-            observer.next(acc);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => observer.complete?.()
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-function reduce(accumulator, seed) {
-  return (source) => {
-    return new Observable((observer) => {
-      let acc = seed;
-      const subscription = source.subscribe(
-        (value) => {
-          try {
-            acc = accumulator(acc, value);
-          } catch (err) {
-            observer.error?.(err);
-          }
-        },
-        (err) => observer.error?.(err),
-        () => {
-          observer.next(acc);
-          observer.complete?.();
-        }
-      );
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-
-// src/shared/observable/subject.ts
-var Subject = class extends Observable {
-  constructor() {
-    super();
-    this.subscribers = /* @__PURE__ */ new Set();
-    this._isCompleted = false;
-    this._hasError = false;
-    this._thrownError = null;
-  }
-  asObservable() {
-    return new Observable((observer) => {
-      const subscription = this.subscribe(observer);
-      return () => subscription.unsubscribe();
-    });
-  }
-  subscribe(observerOrNext, error, complete) {
-    if (this._isCompleted) {
-      const obs = typeof observerOrNext === "function" ? { complete } : observerOrNext;
-      obs.complete?.();
-      return { unsubscribe: () => {
-      } };
-    }
-    if (this._hasError) {
-      return { unsubscribe: () => {
-      } };
-    }
-    const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-    this.subscribers.add(observer);
-    return {
-      unsubscribe: () => {
-        this.subscribers.delete(observer);
-      }
-    };
-  }
-  next(value) {
-    if (this._isCompleted || this._hasError) return;
-    const currentSubscribers = Array.from(this.subscribers);
-    currentSubscribers.forEach((observer) => {
-      if (this.subscribers.has(observer)) {
-        try {
-          observer.next(value);
-        } catch (err) {
-          console.error("Error in observer:", err);
-        }
-      }
-    });
-  }
-  error(err) {
-    if (this._isCompleted || this._hasError) return;
-    this._hasError = true;
-    this._thrownError = err;
-    for (const observer of this.subscribers) {
-      observer.error?.(err);
-    }
-    this.subscribers.clear();
-  }
-  complete() {
-    if (this._isCompleted || this._hasError) return;
-    this._isCompleted = true;
-    const currentSubscribers = Array.from(this.subscribers);
-    currentSubscribers.forEach((observer) => {
-      if (observer.complete) {
-        try {
-          observer.complete();
-        } catch (err) {
-          console.error("Error in complete handler:", err);
-        }
-      }
-    });
-    this.subscribers.clear();
-  }
-};
-
-// src/shared/observable/bsubject.ts
-var BehaviorSubject = class extends Subject {
-  constructor(initialValue) {
-    super();
-    this._value = initialValue;
-  }
-  get $value() {
-    return this._value;
-  }
-  next(value) {
-    this._value = value;
-    super.next(value);
-  }
-  subscribe(observerOrNext, error, complete) {
-    const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
-    if (this._hasError) {
-      observer.error?.(this._thrownError);
-      return { unsubscribe: () => {
-      } };
-    }
-    if (this._isCompleted) {
-      observer.complete?.();
-      return { unsubscribe: () => {
-      } };
-    }
-    observer.next(this._value);
-    return super.subscribe(observer);
-  }
-};
 
 // src/shared/component.ts
 var OrcaComponent = class {
@@ -1882,6 +1533,7 @@ var OrcaComponent = class {
 };
 
 // src/shared/module_libs/http_client/module.ts
+import { Observable } from "rxjs";
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2329,9 +1981,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()`);
       }
@@ -2345,11 +2009,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() {
@@ -2436,7 +2095,7 @@ var ServeStaticModule = class _ServeStaticModule {
         const resolvedPath = path.resolve(options.rootPath);
         const indexPath = path.join(resolvedPath, "index.html");
         this.app.use(express.static(resolvedPath));
-        this.app.get(/.*/, (req, res) => {
+        this.app.get(/^\/(?!api).*/, (req, res) => {
           res.sendFile(indexPath);
         });
       }
@@ -2535,6 +2194,7 @@ var RouterModule = class _RouterModule {
 };
 
 // src/node/factory.ts
+import { isObservable, Observable as Observable2 } from "rxjs";
 function createErrorElement(message) {
   return {
     $$typeof: ORCA_ELEMENT_TYPE,
@@ -2621,6 +2281,174 @@ var RouteMatcherService = class {
     return null;
   }
 };
+var ExecutionContextImpl = class {
+  constructor(classRef, handler, request, response) {
+    this.classRef = classRef;
+    this.handler = handler;
+    this.request = request;
+    this.response = response;
+  }
+  getClass() {
+    return this.classRef;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  switchToHttp() {
+    return {
+      getRequest: () => this.request,
+      getResponse: () => this.response
+    };
+  }
+};
+var GuardPipeline = class {
+  static async execute(guards, context, injector) {
+    if (guards.length === 0) {
+      return true;
+    }
+    for (const guardOrClass of guards) {
+      let guardInstance;
+      if (typeof guardOrClass === "function") {
+        guardInstance = await injector.resolve(guardOrClass);
+      } else {
+        guardInstance = guardOrClass;
+      }
+      const result = guardInstance.canActivate(context);
+      if (result && typeof result.subscribe === "function") {
+        const canActivate = await new Promise((resolve2, reject) => {
+          result.subscribe({
+            next: (value) => resolve2(value),
+            error: (err) => reject(err),
+            complete: () => {
+            }
+          });
+        });
+        if (!canActivate) {
+          return false;
+        }
+      } else if (result instanceof Promise) {
+        const canActivate = await result;
+        if (!canActivate) {
+          return false;
+        }
+      } else {
+        if (!result) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+};
+var InterceptorPipeline = class {
+  static async execute(interceptors, context, handler, injector) {
+    if (interceptors.length === 0) {
+      return handler();
+    }
+    let index = 0;
+    const createCallHandler = () => {
+      const currentIndex = index++;
+      return {
+        handle: async () => {
+          if (currentIndex >= interceptors.length) {
+            return new Observable2((observer) => {
+              handler().then((result2) => {
+                observer.next(result2);
+                observer.complete?.();
+              }).catch((error) => {
+                observer.error?.(error);
+              });
+            });
+          }
+          const interceptorOrClass = interceptors[currentIndex];
+          let interceptorInstance;
+          if (typeof interceptorOrClass === "function") {
+            interceptorInstance = await injector.resolve(interceptorOrClass);
+          } else {
+            interceptorInstance = interceptorOrClass;
+          }
+          const result = interceptorInstance.intercept(
+            context,
+            createCallHandler()
+          );
+          if (result instanceof Promise) {
+            return new Observable2((observer) => {
+              result.then((observable) => {
+                observable.subscribe({
+                  next: (value) => observer.next(value),
+                  error: (err) => observer.error?.(err),
+                  complete: () => observer.complete?.()
+                });
+              }).catch((error) => observer.error?.(error));
+            });
+          }
+          return result;
+        }
+      };
+    };
+    return new Promise(async (resolve2, reject) => {
+      const observable = createCallHandler().handle();
+      let result;
+      (await observable).subscribe({
+        next: (value) => {
+          result = value;
+        },
+        error: (error) => {
+          reject(error);
+        },
+        complete: () => {
+          resolve2(result);
+        }
+      });
+    });
+  }
+};
+var DependenciesScanner = class {
+  constructor() {
+    this.scannedGuards = /* @__PURE__ */ new Set();
+    this.scannedInterceptors = /* @__PURE__ */ new Set();
+  }
+  scanController(controller) {
+    this.scanGuardsFromMetadata(controller);
+    this.scanInterceptorsFromMetadata(controller);
+    const methodKeys = Reflect.ownKeys(controller.prototype);
+    for (const methodKey of methodKeys) {
+      this.scanGuardsFromMetadata(controller.prototype, methodKey);
+      this.scanInterceptorsFromMetadata(controller.prototype, methodKey);
+    }
+  }
+  scanGuardsFromMetadata(target, propertyKey) {
+    const guards = propertyKey ? Reflect.getMetadata(GUARDS_KEY, target, propertyKey) : Reflect.getMetadata(GUARDS_KEY, target);
+    if (!guards) return;
+    for (const guard of guards) {
+      if (typeof guard === "function") {
+        this.scannedGuards.add(guard);
+      }
+    }
+  }
+  scanInterceptorsFromMetadata(target, propertyKey) {
+    const interceptors = propertyKey ? Reflect.getMetadata(INTERCEPTORS_KEY, target, propertyKey) : Reflect.getMetadata(INTERCEPTORS_KEY, target);
+    if (!interceptors) return;
+    for (const interceptor of interceptors) {
+      if (typeof interceptor === "function") {
+        this.scannedInterceptors.add(interceptor);
+      }
+    }
+  }
+  getGuards() {
+    return Array.from(this.scannedGuards);
+  }
+  getInterceptors() {
+    return Array.from(this.scannedInterceptors);
+  }
+  getProviders() {
+    const guards = this.getGuards().map((g) => ProviderNormalizer.normalize(g));
+    const interceptors = this.getInterceptors().map(
+      (i) => ProviderNormalizer.normalize(i)
+    );
+    return [...guards, ...interceptors];
+  }
+};
 var ControllerRegistrationService = class {
   constructor(injector, app) {
     this.injector = injector;
@@ -2640,17 +2468,17 @@ var ControllerRegistrationService = class {
       actor.subscribe(eventName, (data) => handler.call(instance, data));
     }
   }
-  buildMethodArgs(req, paramsMeta, designParams) {
+  buildMethodArgs(req, res, paramsMeta, designParams) {
     const args = Array(designParams.length).fill(void 0);
     for (let i = 0; i < designParams.length; i++) {
       const meta = paramsMeta[i];
       if (!meta) continue;
-      const source = this.getParamSource(req, meta.type);
+      const source = this.getParamSource(req, res, meta.type);
       args[i] = meta.key ? source?.[meta.key] : source;
     }
     return args;
   }
-  getParamSource(req, type) {
+  getParamSource(req, res, type) {
     switch (type) {
       case "BODY" /* BODY */:
         return req.body;
@@ -2658,13 +2486,21 @@ var ControllerRegistrationService = class {
         return req.params;
       case "QUERY" /* QUERY */:
         return req.query;
+      case "FILE" /* FILE */:
+        return req.file;
+      case "FILES" /* FILES */:
+        return req.files;
+      case "REQUEST" /* REQUEST */:
+        return req;
+      case "RESPONSE" /* RESPONSE */:
+        return res;
       default:
         return void 0;
     }
   }
   async handleMethodResult(result, res, isSSE) {
     if (res.headersSent) return;
-    if (isSSE && result instanceof Observable) {
+    if (isSSE && isObservable(result)) {
       result.subscribe({
         next: (data) => {
           res.write(`data: ${JSON.stringify(data)}
@@ -2707,6 +2543,8 @@ var ControllerRegistrationService = class {
       methodKey
     );
     const paramsMeta = Reflect.getMetadata(PARAMS_META_KEY, CtrlCls.prototype, methodKey) ?? {};
+    const guards = getGuards(CtrlCls.prototype, methodKey);
+    const interceptors = getInterceptors(CtrlCls.prototype, methodKey);
     this.app[httpMethod](fullPath, async (req, res) => {
       try {
         if (isSSE) {
@@ -2714,16 +2552,52 @@ var ControllerRegistrationService = class {
           res.setHeader("Cache-Control", "no-cache");
           res.setHeader("Connection", "keep-alive");
         }
+        const requestContext = {
+          request: req,
+          response: res,
+          metadata: {}
+        };
         const designParams = Reflect.getMetadata(
           DESIGN_PARAMTYPES,
           CtrlCls.prototype,
           methodKey
         ) ?? [];
-        const args = this.buildMethodArgs(req, paramsMeta, designParams);
-        const result = await instance[methodKey](...args);
+        const context = new ExecutionContextImpl(
+          CtrlCls,
+          instance[methodKey],
+          req,
+          res
+        );
+        const canActivate = await GuardPipeline.execute(
+          guards,
+          context,
+          this.injector
+        );
+        if (!canActivate) {
+          res.status(403).json({
+            statusCode: 403,
+            message: "Forbidden",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const result = await InterceptorPipeline.execute(
+          interceptors,
+          context,
+          async () => {
+            const args = this.buildMethodArgs(
+              req,
+              res,
+              paramsMeta,
+              designParams
+            );
+            return instance[methodKey](...args);
+          },
+          this.injector
+        );
         await this.handleMethodResult(result, res, isSSE);
       } catch (err) {
-        res.send(err.message);
+        res.status(500).send(err.message);
       }
     });
   }
@@ -2731,10 +2605,10 @@ var ControllerRegistrationService = class {
     const normalizedPrefix = prefix === "/" ? "" : `/${prefix.replace(/^\/+|\/+$/g, "")}`;
     return `${normalizedPrefix}/${routePath}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
   }
-  register(CtrlCls) {
-    const instance = this.injector.resolve(CtrlCls);
+  async register(CtrlCls) {
+    const instance = await this.injector.resolve(CtrlCls);
     const prefix = Reflect.getMetadata(CONTROLLER_PREFIX_KEY, CtrlCls) ?? "/";
-    const actor = this.injector.resolve(Actor);
+    const actor = await this.injector.resolve(Actor);
     this.registerEventHandlers(CtrlCls, instance, actor);
     this.registerHttpMethods(CtrlCls, instance, prefix);
   }
@@ -2858,8 +2732,8 @@ var OscRouteHandler = class {
 var SocketService = class {
   static setup(server, injector) {
     const io = new Server(server);
-    io.on("connection", (socket) => {
-      const actor = injector.resolve(Actor);
+    io.on("connection", async (socket) => {
+      const actor = await injector.resolve(Actor);
       actor.register(socket.id, {
         send: (message) => {
           io.to(socket.id).emit("message", message);
@@ -2887,15 +2761,37 @@ var NodeFactory = class {
     }
     return appNode;
   }
-  static createRootInjector(appNode, app, rootModule) {
+  static scanDependencies(appNode) {
+    const scanner = new DependenciesScanner();
+    const rootControllers = [
+      ...store.get("root_controllers")
+    ];
+    rootControllers.forEach((ctrl) => scanner.scanController(ctrl));
+    appNode.traverse((node) => {
+      const providers = [...node.getProviders().values()];
+      const controllers = providers.filter((provider) => {
+        const token = provider.provide;
+        return typeof token === "function" && Reflect.getMetadata(CONTROLLER, token);
+      });
+      controllers.forEach((c) => {
+        if (c.useClass) {
+          scanner.scanController(c.useClass);
+        }
+      });
+    });
+    return scanner;
+  }
+  static createRootInjector(appNode, app, rootModule, scanner) {
     const allProviders = collectAllProvidersFromNode(appNode);
     const rootControllers = [
       ...store.get("root_controllers")
     ].map((p) => ProviderNormalizer.normalize(p));
     const bootstrap = Reflect.getMetadata(BOOTSTRAP, rootModule);
+    const guardAndInterceptorProviders = scanner.getProviders();
     return new Injector([
       ...allProviders,
       ...rootControllers,
+      ...guardAndInterceptorProviders,
       { provide: "OSC_URL", useValue: "/osc" },
       { provide: EXPRESS_ADAPTER_HOST, useValue: app },
       {
@@ -2916,11 +2812,14 @@ var NodeFactory = class {
     rootControllers.forEach((ctrl) => registrationService.register(ctrl));
     appNode.traverse((node) => {
       const providers = [...node.getProviders().values()];
-      const controllers = providers.filter(
-        (provider) => Reflect.getMetadata(CONTROLLER, provider.provide)
-      );
+      const controllers = providers.filter((provider) => {
+        const token = provider.provide;
+        return typeof token === "function" && Reflect.getMetadata(CONTROLLER, token);
+      });
       controllers.forEach((c) => registrationService.register(c.useClass));
-      providers.filter((provider) => provider.eager).forEach((p) => injector.resolve(p.provide));
+      providers.filter((provider) => provider.eager).forEach(async (p) => {
+        await injector.resolve(p.provide);
+      });
     });
   }
   static setupOscRoute(app, injector, rootModule) {
@@ -2933,7 +2832,13 @@ var NodeFactory = class {
     app.use(express2.json());
     const server = http.createServer(app);
     const appNode = this.compileAndValidate(rootModule);
-    const rootInjector = this.createRootInjector(appNode, app, rootModule);
+    const scanner = this.scanDependencies(appNode);
+    const rootInjector = this.createRootInjector(
+      appNode,
+      app,
+      rootModule,
+      scanner
+    );
     setCurrentInjector(rootInjector);
     this.registerControllers(appNode, rootInjector, app);
     this.setupOscRoute(app, rootInjector, rootModule);
@@ -2946,7 +2851,6 @@ export {
   ActorModule,
   BOOTSTRAP,
   BOOTSTRAP_VNODE,
-  BehaviorSubject,
   Body,
   COMPONENT,
   COMPONENT_DEPS,
@@ -2965,6 +2869,7 @@ export {
   EXPORTS_KEY,
   EXPRESS_ADAPTER_HOST,
   Fragment,
+  GUARDS_KEY,
   Get,
   HTTP_METHOD_KEY,
   HandlerParamType,
@@ -2974,6 +2879,7 @@ export {
   IMPORTS_KEY,
   INJECTABLE,
   INJECT_TOKENS_KEY,
+  INTERCEPTORS_KEY,
   Inject,
   Injectable,
   Injector,
@@ -2986,7 +2892,6 @@ export {
   ORCA_ELEMENT_TYPE,
   ORCA_FRAGMENT_TYPE,
   OSC,
-  Observable,
   OrcaComponent,
   PARAMS_META_KEY,
   PATH_KEY,
@@ -2996,56 +2901,47 @@ export {
   Post,
   ProviderNormalizer,
   Query,
+  REQUEST_CONTEXT,
+  Req,
+  Res,
   RouterModule,
   SIGNATURE_METADATA_KEY,
   SSE_ROUTE,
   ServeStaticModule,
+  SetMetadata,
+  Shared,
   Signature,
   Sse,
-  Subject,
   Subscribe,
-  assert$,
+  UploadedFile,
+  UploadedFiles,
+  UseGuards,
+  UseInterceptors,
+  applyDecorators,
   batch,
-  catchError,
   collectAllProvidersFromNode,
   computed,
-  concatMap,
   createRoot,
-  debounceTime,
-  distinctUntilChanged,
   effect,
-  filter,
-  from,
   getCurrentInjector,
+  getGuards,
+  getInterceptors,
   getSignatureMetadata,
   hasSignature,
-  interval,
   isClassComponent,
   isFragment,
   isIntrinsicElement,
-  isObservable,
   isSignal,
   jsx,
   jsxs,
-  map,
-  mergeMap,
+  mixin,
   node_exports as node,
-  observable,
-  of,
   parseSignatureSchemas,
-  reduce,
-  scan,
   setCurrentInjector,
   shared_exports as shared,
   signal,
-  skip,
-  startWith,
-  switchMap,
   symbolValueReplacer,
   symbolValueReviver,
-  take,
-  tap,
-  throttleTime,
   toSignal,
   untracked
 };