@xyo-network/bridge-http 2.111.2 → 3.0.0

package/dist/node/index.d.ts

@@ -1,3 +1,128 @@
-export * from './HttpBridgeConfig.ts';
-export * from './HttpBridgeFull.ts';
-//# sourceMappingURL=index.d.ts.map
+import * as _xylabs_object from '@xylabs/object';
+import { EmptyObject } from '@xylabs/object';
+import { BridgeConfig, BridgeModule, BridgeExposeOptions, BridgeUnexposeOptions, BridgeParams } from '@xyo-network/bridge-model';
+import * as _store__types_express_serve_static_core_npm_4_19_5_6a71bb1fe8_package from '.store/@types-express-serve-static-core-npm-4.19.5-6a71bb1fe8/package';
+import { Server } from 'node:http';
+import { Address } from '@xylabs/hex';
+import { QueryBoundWitness } from '@xyo-network/boundwitness-model';
+import * as _xyo_network_module_model from '@xyo-network/module-model';
+import { ModuleQueryResult, ModuleInstance, ModuleIdentifier, ModuleFilterOptions, AnyConfigSchema } from '@xyo-network/module-model';
+import * as _xyo_network_payload_model from '@xyo-network/payload-model';
+import { Payload, Schema } from '@xyo-network/payload-model';
+import express, { Application, Request, Response } from 'express';
+import * as _xyo_network_account from '@xyo-network/account';
+import { ModuleProxyParams, BridgeModuleResolverParams, AbstractBridgeModuleResolver, AbstractBridge } from '@xyo-network/bridge-abstract';
+import { Mutex, Semaphore } from 'async-mutex';
+import { LRUCache } from 'lru-cache';
+import { AxiosJson } from '@xylabs/axios';
+import { Promisable } from '@xylabs/promise';
+
+type HttpBridgeConfigSchema = 'network.xyo.bridge.http.config';
+declare const HttpBridgeConfigSchema: HttpBridgeConfigSchema;
+type HttpBridgeConfig<TConfig extends EmptyObject = EmptyObject, TSchema extends string | void = void> = BridgeConfig<{
+    client?: BridgeConfig['client'] & {
+        url: string;
+    };
+    failureRetryTime?: number;
+    failureTimeCacheMax?: number;
+    host?: {
+        port: number;
+    };
+    maxConnections?: number;
+    maxPayloadSizeWarning?: number;
+    nodeUrl?: string;
+    schema: HttpBridgeConfigSchema;
+} & TConfig, TSchema extends string ? TSchema : HttpBridgeConfigSchema>;
+
+interface BridgeQuerySender {
+    sendBridgeQuery: <TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(targetAddress: Address, query: TQuery, payloads?: TIn[]) => Promise<ModuleQueryResult<TOut>>;
+}
+type HttpModuleProxyParams = ModuleProxyParams & {
+    querySender: BridgeQuerySender;
+};
+
+interface HttpBridgeModuleResolverParams extends BridgeModuleResolverParams {
+    querySender: BridgeQuerySender;
+    rootUrl: string;
+}
+declare class HttpBridgeModuleResolver<T extends HttpBridgeModuleResolverParams = HttpBridgeModuleResolverParams> extends AbstractBridgeModuleResolver<T> {
+    protected _resolvedCache: LRUCache<Lowercase<string>, ModuleInstance<_xylabs_object.BaseParamsFields & {
+        account?: _xyo_network_account.AccountInstance | "random";
+        addToResolvers?: boolean;
+        additionalSigners?: _xyo_network_account.AccountInstance[];
+        allowNameResolution?: boolean;
+        config: _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & Omit<_xyo_network_module_model.ArchivingModuleConfig & _xyo_network_module_model.ModuleConfigFields & _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & {
+            schema: "network.xyo.module.config";
+        }, "schema"> & {
+            schema: string;
+        };
+        ephemeralQueryAccountEnabled?: boolean;
+        moduleIdentifierTransformers?: _xyo_network_module_model.ModuleIdentifierTransformer[];
+    }, _xyo_network_module_model.ModuleEventData<object>> | {
+        notFound: boolean;
+    }, unknown>;
+    protected _resolvedCacheMutex: Mutex;
+    get querySender(): BridgeQuerySender;
+    moduleUrl(address: Address): URL;
+    resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>, params?: Partial<HttpModuleProxyParams>): Promise<T[]>;
+}
+
+interface HttpBridgeParams$1 extends BridgeParams<AnyConfigSchema<HttpBridgeConfig>> {
+    axios?: AxiosJson;
+}
+declare class HttpBridgeBase<TParams extends HttpBridgeParams$1> extends AbstractBridge<TParams> implements BridgeModule<TParams>, BridgeQuerySender {
+    static axios: AxiosJson;
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static defaultFailureRetryTime: number;
+    static defaultMaxConnections: number;
+    static defaultMaxPayloadSizeWarning: number;
+    static maxFailureCacheSize: number;
+    private _axios?;
+    private _discoverRootsMutex;
+    private _failureTimeCache;
+    private _querySemaphore?;
+    private _resolver?;
+    get axios(): AxiosJson;
+    get clientUrl(): string;
+    get failureRetryTime(): number;
+    get maxConnections(): number;
+    get maxPayloadSizeWarning(): number;
+    get querySemaphore(): Semaphore;
+    get resolver(): HttpBridgeModuleResolver<HttpBridgeModuleResolverParams>;
+    exposeHandler(_id: string, _options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]>;
+    exposedHandler(): Promisable<Address[]>;
+    getRoots(force?: boolean): Promise<ModuleInstance[]>;
+    moduleUrl(address: Address): URL;
+    sendBridgeQuery<TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(targetAddress: Address, query: TQuery, payloads?: TIn[]): Promise<ModuleQueryResult<TOut>>;
+    unexposeHandler(_id: string, _options?: BridgeUnexposeOptions | undefined): Promisable<ModuleInstance[]>;
+    private getRootState;
+    private resolveRootNode;
+}
+
+type AddressPathParams = {
+    address: Address;
+};
+type PostAddressRequestBody = [QueryBoundWitness, undefined | Payload[]];
+interface HttpBridgeParams extends BridgeParams<AnyConfigSchema<HttpBridgeConfig>> {
+}
+declare class HttpBridge<TParams extends HttpBridgeParams> extends HttpBridgeBase<TParams> {
+    protected _app?: Application;
+    protected _exposedModules: WeakRef<ModuleInstance>[];
+    protected _server?: Server;
+    protected get app(): express.Application;
+    exposeChild(mod: ModuleInstance, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]>;
+    exposeHandler(address: Address, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]>;
+    exposedHandler(): Address[];
+    startHandler(): Promise<boolean>;
+    stopHandler(_timeout?: number | undefined): Promise<boolean>;
+    unexposeHandler(address: Address, options?: BridgeUnexposeOptions | undefined): Promise<ModuleInstance[]>;
+    protected callLocalModule(address: Address, query: QueryBoundWitness, payloads: Payload[]): Promise<ModuleQueryResult | null>;
+    protected handleGet(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response): Promise<void>;
+    protected handlePost(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response): Promise<express.Response<any, Record<string, any>> | undefined>;
+    protected initializeApp(): _store__types_express_serve_static_core_npm_4_19_5_6a71bb1fe8_package.Express;
+    protected startHttpServer(): Promise<boolean>;
+    protected stopHttpServer(): Promise<boolean>;
+}
+
+export { HttpBridge, type HttpBridgeConfig, HttpBridgeConfigSchema, type HttpBridgeParams };

package/dist/node/index.mjs

@@ -1,10 +1,5 @@
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __reflectGet = Reflect.get;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
 
 // src/HttpBridgeConfig.ts
 var HttpBridgeConfigSchema = "network.xyo.bridge.http.config";
@@ -50,7 +45,11 @@ import { forget } from "@xylabs/forget";
 import { isAddress } from "@xylabs/hex";
 import { AbstractModuleProxy } from "@xyo-network/bridge-abstract";
 import { ResolveHelper } from "@xyo-network/module-model";
-var _HttpModuleProxy = class _HttpModuleProxy extends AbstractModuleProxy {
+var HttpModuleProxy = class _HttpModuleProxy extends AbstractModuleProxy {
+  static {
+    __name(this, "HttpModuleProxy");
+  }
+  static createCount = 0;
   constructor(params) {
     _HttpModuleProxy.createCount = _HttpModuleProxy.createCount + 1;
     super(params);
@@ -98,7 +97,7 @@ var _HttpModuleProxy = class _HttpModuleProxy extends AbstractModuleProxy {
         const address = isAddress(first) ? first : this.id === first ? this.address : this.childAddressByName(first);
         if (!address) return void 0;
         const firstInstance = await this.params.host.resolve(address);
-        return remainingPath ? await (firstInstance == null ? void 0 : firstInstance.resolve(remainingPath)) : firstInstance;
+        return remainingPath ? await firstInstance?.resolve(remainingPath) : firstInstance;
       }
       case "object": {
         return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
@@ -109,15 +108,15 @@ var _HttpModuleProxy = class _HttpModuleProxy extends AbstractModuleProxy {
     }
   }
 };
-__name(_HttpModuleProxy, "HttpModuleProxy");
-__publicField(_HttpModuleProxy, "createCount", 0);
-var HttpModuleProxy = _HttpModuleProxy;
 
 // src/HttpBridgeModuleResolver.ts
 var NotFoundModule = {
   notFound: true
 };
-var _HttpBridgeModuleResolver = class _HttpBridgeModuleResolver extends AbstractBridgeModuleResolver {
+var HttpBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
+  static {
+    __name(this, "HttpBridgeModuleResolver");
+  }
   _resolvedCache = new LRUCache({
     max: 1e3
   });
@@ -139,13 +138,12 @@ var _HttpBridgeModuleResolver = class _HttpBridgeModuleResolver extends Abstract
     assertEx2(isAddress2(firstPart), () => `Invalid module address: ${firstPart}`);
     const remainderParts = idParts.join(":");
     const instance = await this._resolvedCacheMutex.runExclusive(async () => {
-      var _a, _b, _c, _d, _e;
       const cachedMod = this._resolvedCache.get(firstPart);
       if (cachedMod) {
         if (isModuleInstance(cachedMod)) {
           const result2 = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, {
             ...options,
-            maxDepth: ((options == null ? void 0 : options.maxDepth) ?? 5) - 1
+            maxDepth: (options?.maxDepth ?? 5) - 1
           });
           return result2;
         } else {
@@ -166,37 +164,35 @@ var _HttpBridgeModuleResolver = class _HttpBridgeModuleResolver extends Abstract
         querySender: this.params.querySender,
         ...params
       };
-      (_a = this.logger) == null ? void 0 : _a.debug(`creating HttpProxy [${firstPart}] ${id}`);
+      this.logger?.debug(`creating HttpProxy [${firstPart}] ${id}`);
       const proxy = new HttpModuleProxy(finalParams);
       let state;
       try {
         state = await proxy.state();
       } catch (ex) {
         const error = ex;
-        (_b = this.logger) == null ? void 0 : _b.log(error.message);
+        this.logger?.log(error.message);
       }
       if (!state) {
         this._resolvedCache.set(firstPart, NotFoundModule);
         return;
       }
-      const configSchema = (_c = state.find((payload) => payload.schema === ConfigSchema)) == null ? void 0 : _c.config;
+      const configSchema = state.find((payload) => payload.schema === ConfigSchema)?.config;
       const config = assertEx2(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
       proxy.setConfig(config);
-      (_d = this.logger) == null ? void 0 : _d.log(`created HttpProxy [${firstPart}] ${proxy.id}`);
-      await ((_e = proxy.start) == null ? void 0 : _e.call(proxy));
+      this.logger?.log(`created HttpProxy [${firstPart}] ${proxy.id}`);
+      await proxy.start?.();
       const wrapped = wrapModuleWithType(proxy, account);
       assertEx2(asModuleInstance(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
       this._resolvedCache.set(wrapped.address, wrapped);
       return wrapped;
     });
-    const result = remainderParts.length > 0 ? await (instance == null ? void 0 : instance.resolve(remainderParts, options)) : instance;
+    const result = remainderParts.length > 0 ? await instance?.resolve(remainderParts, options) : instance;
     return result ? [
       result
     ] : [];
   }
 };
-__name(_HttpBridgeModuleResolver, "HttpBridgeModuleResolver");
-var HttpBridgeModuleResolver = _HttpBridgeModuleResolver;
 
 // src/HttpBridgeBase.ts
 function _ts_decorate(decorators, target, key, desc) {
@@ -206,7 +202,20 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
+var HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
+  static {
+    __name(this, "HttpBridgeBase");
+  }
+  static axios = new AxiosJson();
+  static configSchemas = [
+    ...super.configSchemas,
+    HttpBridgeConfigSchema
+  ];
+  static defaultConfigSchema = HttpBridgeConfigSchema;
+  static defaultFailureRetryTime = 1e3 * 60;
+  static defaultMaxConnections = 4;
+  static defaultMaxPayloadSizeWarning = 256 * 256;
+  static maxFailureCacheSize = 1e3;
   _axios;
   _discoverRootsMutex = new Mutex2();
   _failureTimeCache = new LRUCache2({
@@ -219,8 +228,7 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
     return this._axios;
   }
   get clientUrl() {
-    var _a;
-    return assertEx3(((_a = this.config.client) == null ? void 0 : _a.url) ?? this.config.nodeUrl, () => "No Url Set");
+    return assertEx3(this.config.client?.url ?? this.config.nodeUrl, () => "No Url Set");
   }
   get failureRetryTime() {
     return this.config.failureRetryTime ?? _HttpBridgeBase.defaultFailureRetryTime;
@@ -270,14 +278,13 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
   }
   async getRoots(force) {
     return await this._discoverRootsMutex.runExclusive(async () => {
-      var _a, _b;
       if (this._roots === void 0 || force) {
         const state = await this.getRootState();
-        (_a = this.logger) == null ? void 0 : _a.debug(`HttpBridge:discoverRoots.state [${state == null ? void 0 : state.length}]`);
-        const nodeManifest = state == null ? void 0 : state.find(isPayloadOfSchemaType(NodeManifestPayloadSchema));
+        this.logger?.debug(`HttpBridge:discoverRoots.state [${state?.length}]`);
+        const nodeManifest = state?.find(isPayloadOfSchemaType(NodeManifestPayloadSchema));
         if (nodeManifest) {
           const mods = (await this.resolveRootNode(nodeManifest)).filter(exists2);
-          (_b = this.logger) == null ? void 0 : _b.debug(`HttpBridge:discoverRoots [${mods.length}]`);
+          this.logger?.debug(`HttpBridge:discoverRoots [${mods.length}]`);
           this._roots = mods;
         } else {
           this._roots = [];
@@ -290,7 +297,6 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
     return new URL(address, this.clientUrl);
   }
   async sendBridgeQuery(targetAddress, query, payloads) {
-    var _a, _b, _c, _d;
     const lastFailureTime = this._failureTimeCache.get(targetAddress);
     if (lastFailureTime !== void 0) {
       const now = Date.now();
@@ -307,7 +313,7 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
         payloads
       ]).length;
       if (payloadSize > this.maxPayloadSizeWarning) {
-        (_a = this.logger) == null ? void 0 : _a.warn(`Large targetQuery being sent: ${payloadSize} bytes [${this.address}][${this.moduleAddress}] [${query.schema}] [${payloads == null ? void 0 : payloads.length}]`);
+        this.logger?.warn(`Large targetQuery being sent: ${payloadSize} bytes [${this.address}][${this.moduleAddress}] [${query.schema}] [${payloads?.length}]`);
       }
       const moduleUrl = this.moduleUrl(targetAddress).href;
       const result = await this.axios.post(moduleUrl, [
@@ -318,13 +324,13 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
         throw `target module not found [${moduleUrl}] [${result.status}]`;
       }
       if (result.status >= 400) {
-        (_b = this.logger) == null ? void 0 : _b.error(`targetQuery failed [${moduleUrl}]`);
+        this.logger?.error(`targetQuery failed [${moduleUrl}]`);
         throw `targetQuery failed [${moduleUrl}] [${result.status}]`;
       }
-      return (_c = result.data) == null ? void 0 : _c.data;
+      return result.data?.data;
     } catch (ex) {
       const error = ex;
-      (_d = this.logger) == null ? void 0 : _d.error(`Error: ${toJsonString(error)}`);
+      this.logger?.error(`Error: ${toJsonString(error)}`);
       throw error;
     } finally {
       this.querySemaphore.release();
@@ -334,7 +340,6 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
     throw new Error("Unsupported");
   }
   async getRootState() {
-    var _a;
     const queryPayload = {
       schema: ModuleStateQuerySchema
     };
@@ -351,17 +356,13 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
       return payloads;
     } catch (ex) {
       const error = ex;
-      (_a = this.logger) == null ? void 0 : _a.warn(`Unable to connect to remote node: ${error.message} [${this.clientUrl}]`);
+      this.logger?.warn(`Unable to connect to remote node: ${error.message} [${this.clientUrl}]`);
     }
   }
   async resolveRootNode(nodeManifest) {
-    var _a;
-    const rootModule = assertEx3((await this.resolver.resolveHandler(assertEx3((_a = nodeManifest.status) == null ? void 0 : _a.address, () => "Root has no address"), void 0, {
+    const rootModule = assertEx3((await this.resolver.resolveHandler(assertEx3(nodeManifest.status?.address, () => "Root has no address"), void 0, {
       manifest: nodeManifest
-    })).at(0), () => {
-      var _a2;
-      return `Root not found [${(_a2 = nodeManifest.status) == null ? void 0 : _a2.address}]`;
-    });
+    })).at(0), () => `Root not found [${nodeManifest.status?.address}]`);
     assertEx3(rootModule.constructor.name !== "HttpModuleProxy", () => "rootModule is not a Wrapper");
     const rootNode = asAttachableNodeInstance(rootModule, "Root modules is not a node");
     if (rootNode) {
@@ -374,18 +375,6 @@ var _HttpBridgeBase = class _HttpBridgeBase extends AbstractBridge {
     return [];
   }
 };
-__name(_HttpBridgeBase, "HttpBridgeBase");
-__publicField(_HttpBridgeBase, "axios", new AxiosJson());
-__publicField(_HttpBridgeBase, "configSchemas", [
-  ...__superGet(_HttpBridgeBase, _HttpBridgeBase, "configSchemas"),
-  HttpBridgeConfigSchema
-]);
-__publicField(_HttpBridgeBase, "defaultConfigSchema", HttpBridgeConfigSchema);
-__publicField(_HttpBridgeBase, "defaultFailureRetryTime", 1e3 * 60);
-__publicField(_HttpBridgeBase, "defaultMaxConnections", 4);
-__publicField(_HttpBridgeBase, "defaultMaxPayloadSizeWarning", 256 * 256);
-__publicField(_HttpBridgeBase, "maxFailureCacheSize", 1e3);
-var HttpBridgeBase = _HttpBridgeBase;
 HttpBridgeBase = _ts_decorate([
   creatableModule()
 ], HttpBridgeBase);
@@ -398,7 +387,10 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
+var HttpBridge = class extends HttpBridgeBase {
+  static {
+    __name(this, "HttpBridge");
+  }
   _app;
   _exposedModules = [];
   _server;
@@ -407,11 +399,10 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return assertEx4(this._app, () => "App not initialized");
   }
   async exposeChild(mod, options) {
-    var _a, _b;
     const { maxDepth = 5 } = options ?? {};
     assertEx4(this.config.host, () => "Not configured as a host");
     this._exposedModules.push(new WeakRef(mod));
-    const children = maxDepth > 0 ? await ((_a = mod.publicChildren) == null ? void 0 : _a.call(mod)) ?? [] : [];
+    const children = maxDepth > 0 ? await mod.publicChildren?.() ?? [] : [];
     this.logger.log(`childrenToExpose [${mod.id}][${mod.address}]: ${toJsonString2(children.map((child) => child.id))}`);
     const exposedChildren = (await Promise.all(children.map((child) => this.exposeChild(child, {
       maxDepth: maxDepth - 1,
@@ -421,7 +412,7 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
       mod,
       ...exposedChildren
     ];
-    for (const exposedMod of allExposed) (_b = this.logger) == null ? void 0 : _b.log(`exposed: ${exposedMod.address} [${mod.id}]`);
+    for (const exposedMod of allExposed) this.logger?.log(`exposed: ${exposedMod.address} [${mod.id}]`);
     return allExposed;
   }
   async exposeHandler(address, options) {
@@ -436,10 +427,7 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return [];
   }
   exposedHandler() {
-    return this._exposedModules.map((ref) => {
-      var _a;
-      return (_a = ref.deref()) == null ? void 0 : _a.address;
-    }).filter(exists3);
+    return this._exposedModules.map((ref) => ref.deref()?.address).filter(exists3);
   }
   async startHandler() {
     return await super.startHandler() && await this.startHttpServer();
@@ -448,20 +436,13 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return await super.stopHandler() && await this.stopHttpServer();
   }
   async unexposeHandler(address, options) {
-    var _a, _b;
     const { maxDepth = 2, required = true } = options ?? {};
     assertEx4(this.config.host, () => "Not configured as a host");
-    const mod = (_a = this._exposedModules.find((ref) => {
-      var _a2;
-      return ((_a2 = ref.deref()) == null ? void 0 : _a2.address) === address;
-    })) == null ? void 0 : _a.deref();
+    const mod = this._exposedModules.find((ref) => ref.deref()?.address === address)?.deref();
     assertEx4(!required || mod, () => `Module not exposed: ${address}`);
-    this._exposedModules = this._exposedModules.filter((ref) => {
-      var _a2;
-      return ((_a2 = ref.deref()) == null ? void 0 : _a2.address) !== address;
-    });
+    this._exposedModules = this._exposedModules.filter((ref) => ref.deref()?.address !== address);
     if (mod) {
-      const children = maxDepth > 0 ? await ((_b = mod.publicChildren) == null ? void 0 : _b.call(mod)) ?? [] : [];
+      const children = maxDepth > 0 ? await mod.publicChildren?.() ?? [] : [];
       const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, {
         maxDepth: maxDepth - 1,
         required: false
@@ -474,24 +455,16 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return [];
   }
   async callLocalModule(address, query, payloads) {
-    var _a;
-    const mod = (_a = this._exposedModules.find((ref) => {
-      var _a2;
-      return ((_a2 = ref.deref()) == null ? void 0 : _a2.address) === address;
-    })) == null ? void 0 : _a.deref();
+    const mod = this._exposedModules.find((ref) => ref.deref()?.address === address)?.deref();
     return mod ? await mod.query(query, payloads) : null;
   }
   async handleGet(req, res) {
-    var _a;
     const { address } = req.params;
     try {
       if (address == this.address) {
         res.json(await this.stateQuery(this.account));
       } else {
-        const mod = (_a = this._exposedModules.find((ref) => {
-          var _a2;
-          return ((_a2 = ref.deref()) == null ? void 0 : _a2.address) === address;
-        })) == null ? void 0 : _a.deref();
+        const mod = this._exposedModules.find((ref) => ref.deref()?.address === address)?.deref();
         if (mod) {
           res.json(await mod.stateQuery(this.account));
         } else {
@@ -559,10 +532,9 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return app;
   }
   startHttpServer() {
-    var _a;
     if (this.config.host) {
       assertEx4(!this._server, () => "Server already started");
-      this._server = this.app.listen(((_a = this.config.host) == null ? void 0 : _a.port) ?? 3030);
+      this._server = this.app.listen(this.config.host?.port ?? 3030);
     }
     return Promise.resolve(true);
   }
@@ -584,8 +556,6 @@ var _HttpBridge = class _HttpBridge extends HttpBridgeBase {
     return Promise.resolve(true);
   }
 };
-__name(_HttpBridge, "HttpBridge");
-var HttpBridge = _HttpBridge;
 HttpBridge = _ts_decorate2([
   creatableModule2()
 ], HttpBridge);