@xyo-network/sdk 2.102.3 → 7.0.2

package/dist/_pkg/bridge-http/neutral/index.mjs

@@ -0,0 +1,380 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+
+// src/HttpBridge.ts
+import {
+  assertEx as assertEx2,
+  exists as exists2,
+  FetchClientError,
+  FetchJsonClient,
+  forget as forget2,
+  toSafeJsonString
+} from "@xylabs/sdk";
+import { AbstractBridge } from "../../bridge-abstract/neutral/index.mjs";
+import {
+  creatableModule as creatableModule2,
+  ModuleStateQuerySchema
+} from "../../module-model/neutral/index.mjs";
+import { asAttachableNodeInstance } from "../../node-model/neutral/index.mjs";
+import { isPayloadOfSchemaType, NodeManifestPayloadSchema } from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex as Mutex2, Semaphore } from "async-mutex";
+import { LRUCache as LRUCache2 } from "lru-cache";
+
+// src/HttpBridgeConfig.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { BridgeConfigZod } from "../../bridge-model/neutral/index.mjs";
+import { asSchema } from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+var HttpBridgeConfigSchema = asSchema("network.xyo.bridge.http.config", true);
+var HttpBridgeConfigZod = z.extend(BridgeConfigZod, {
+  client: z.optional(z.custom()),
+  failureRetryTime: z.optional(z.number()),
+  failureTimeCacheMax: z.optional(z.number()),
+  host: z.optional(z.custom()),
+  maxConnections: z.optional(z.number()),
+  maxPayloadSizeWarning: z.optional(z.number()),
+  schema: z.literal(HttpBridgeConfigSchema)
+});
+var isHttpBridgeConfig = zodIsFactory(HttpBridgeConfigZod);
+var asHttpBridgeConfig = zodAsFactory(HttpBridgeConfigZod, "asHttpBridgeConfig");
+var toHttpBridgeConfig = zodToFactory(HttpBridgeConfigZod, "toHttpBridgeConfig");
+
+// src/HttpBridgeModuleResolver.ts
+import {
+  assertEx,
+  isAddress as isAddress2,
+  isDefined
+} from "@xylabs/sdk";
+import { AbstractBridgeModuleResolver, wrapModuleWithType } from "../../bridge-abstract/neutral/index.mjs";
+import {
+  asModuleInstance,
+  isModuleInstance,
+  ModuleConfigSchema
+} from "../../module-model/neutral/index.mjs";
+import { ResolveHelper as ResolveHelper2 } from "../../module-resolver/neutral/index.mjs";
+import { Account, ConfigSchema } from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+import { LRUCache } from "lru-cache";
+
+// src/ModuleProxy/ModuleProxy.ts
+import {
+  exists,
+  forget,
+  isAddress,
+  isString
+} from "@xylabs/sdk";
+import { AbstractModuleProxy } from "../../bridge-abstract/neutral/index.mjs";
+import { creatableModule } from "../../module-model/neutral/index.mjs";
+import { ResolveHelper } from "../../module-resolver/neutral/index.mjs";
+var HttpModuleProxy = class extends AbstractModuleProxy {
+  async proxyQueryHandler(query, payloads = []) {
+    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+      forget(this.storeToArchivists([query, ...payloads ?? []]));
+    }
+    const result = await this.params.querySender.sendBridgeQuery(this.params.moduleAddress, query, payloads);
+    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+      forget(this.storeToArchivists(result.flat()));
+    }
+    return result;
+  }
+  async publicChildren() {
+    return (await Promise.all(
+      Object.values(await this.childAddressMap()).filter(exists).map((address) => this.resolve(address))
+    )).filter(exists);
+  }
+  async resolve(id = "*", options = {}) {
+    const config = {
+      address: this.address,
+      dead: this.dead,
+      downResolver: this.downResolver,
+      logger: this.logger,
+      mod: this,
+      transformers: this.moduleIdentifierTransformers,
+      upResolver: this.upResolver
+    };
+    if (id === "*") {
+      return [...await this.publicChildren(), await this.params.host.resolve(this.address)];
+    }
+    switch (typeof id) {
+      case "string": {
+        const parts = id.split(":");
+        const first = parts.shift();
+        if (isString(first)) {
+          const remainingPath = parts.length > 0 ? parts.join(":") : void 0;
+          const address = isAddress(first) ? first : this.id === first ? this.address : this.childAddressByName(first);
+          if (!isAddress(address)) return void 0;
+          const firstInstance = await this.params.host.resolve(address);
+          return isString(remainingPath) ? await firstInstance?.resolve(remainingPath) : firstInstance;
+        }
+        return void 0;
+      }
+      default: {
+        return (await ResolveHelper.resolve(config, id, options)).filter((mod) => mod.address !== this.address);
+      }
+    }
+  }
+};
+HttpModuleProxy = __decorateClass([
+  creatableModule()
+], HttpModuleProxy);
+
+// src/HttpBridgeModuleResolver.ts
+var NotFoundModule = { notFound: true };
+var HttpBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
+  _resolvedCache = new LRUCache({ max: 1e3 });
+  _resolvedCacheMutex = new Mutex();
+  get querySender() {
+    return this.params.querySender;
+  }
+  moduleUrl(address) {
+    return new URL(address, this.params.rootUrl);
+  }
+  async resolveHandler(id, options, params) {
+    const parentResult = await super.resolveHandler(id, options);
+    if (parentResult.length > 0) {
+      return parentResult;
+    }
+    const idParts = id.split(":");
+    const untransformedFirstPart = assertEx(idParts.shift(), () => "Missing module identifier");
+    const firstPart = await ResolveHelper2.transformModuleIdentifier(untransformedFirstPart);
+    assertEx(isAddress2(firstPart), () => `Invalid module address: ${firstPart}`);
+    const remainderParts = idParts.join(":");
+    const instance = await this._resolvedCacheMutex.runExclusive(async () => {
+      const cachedMod = this._resolvedCache.get(firstPart);
+      if (cachedMod) {
+        if (isModuleInstance(cachedMod)) {
+          const result2 = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 });
+          return result2;
+        } else {
+          return;
+        }
+      }
+      const account = await Account.random();
+      const finalParams = {
+        name: "HttpBridgeModuleResolver",
+        account,
+        archiving: this.params.archiving,
+        config: { schema: ModuleConfigSchema },
+        host: this,
+        moduleAddress: firstPart,
+        onQuerySendFinished: this.params.onQuerySendFinished,
+        onQuerySendStarted: this.params.onQuerySendStarted,
+        querySender: this.params.querySender,
+        ...params
+      };
+      this.logger?.debug(`creating HttpProxy [${firstPart}] ${id}`);
+      let proxy;
+      let state;
+      try {
+        proxy = await HttpModuleProxy.create(finalParams);
+        state = await proxy.state();
+      } catch (ex) {
+        const error = ex;
+        this.logger?.error(error.message);
+      }
+      if (isDefined(proxy)) {
+        if (!state) {
+          this._resolvedCache.set(firstPart, NotFoundModule);
+          return;
+        }
+        const configSchema = state.find((payload) => payload.schema === ConfigSchema)?.config;
+        const config = assertEx(
+          state.find((payload) => payload.schema === configSchema),
+          () => "Unable to locate config"
+        );
+        proxy.setConfig(config);
+        this.logger?.log(`created HttpProxy [${firstPart}] ${proxy.id}`);
+        await proxy.start?.();
+        const wrapped = wrapModuleWithType(proxy, account);
+        assertEx(asModuleInstance(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
+        this._resolvedCache.set(wrapped.address, wrapped);
+        return wrapped;
+      }
+    });
+    const result = remainderParts.length > 0 ? await instance?.resolve(remainderParts, options) : instance;
+    return result ? [result] : [];
+  }
+};
+
+// src/HttpBridge.ts
+var HttpBridge = class extends AbstractBridge {
+  _discoverRootsMutex = new Mutex2();
+  _failureTimeCache = new LRUCache2({ max: HttpBridge.maxFailureCacheSize });
+  _fetchClient;
+  _querySemaphore;
+  _resolver;
+  get clientUrl() {
+    return assertEx2(this.config.client?.url, () => "No Url Set");
+  }
+  get failureRetryTime() {
+    return this.config.failureRetryTime ?? HttpBridge.defaultFailureRetryTime;
+  }
+  get fetchClient() {
+    this._fetchClient = this._fetchClient ?? this.params.fetchClient ?? HttpBridge.fetchClient;
+    return this._fetchClient;
+  }
+  get maxConnections() {
+    return this.config.maxConnections ?? HttpBridge.defaultMaxConnections;
+  }
+  get maxPayloadSizeWarning() {
+    return this.config.maxPayloadSizeWarning ?? HttpBridge.defaultMaxPayloadSizeWarning;
+  }
+  get querySemaphore() {
+    this._querySemaphore = this._querySemaphore ?? new Semaphore(this.maxConnections);
+    return this._querySemaphore;
+  }
+  get resolver() {
+    this._resolver = this._resolver ?? new HttpBridgeModuleResolver({
+      additionalSigners: this.additionalSigners,
+      archiving: { ...this.archiving, resolveArchivists: this.resolveArchivingArchivists.bind(this) },
+      bridge: this,
+      onQuerySendFinished: (args) => {
+        forget2(this.emit("querySendFinished", { mod: this, ...args }));
+      },
+      onQuerySendStarted: (args) => {
+        forget2(this.emit("querySendStarted", { mod: this, ...args }));
+      },
+      querySender: this,
+      root: this,
+      rootUrl: this.clientUrl,
+      wrapperAccount: this.account
+    });
+    return this._resolver;
+  }
+  exposeHandler(_id, _options) {
+    throw new Error("Unsupported");
+  }
+  exposedHandler() {
+    throw new Error("Unsupported");
+  }
+  async getRoots(force) {
+    return await this._discoverRootsMutex.runExclusive(async () => {
+      if (this._roots === void 0 || force) {
+        const state = await this.getRootState();
+        this.logger?.debug(`HttpBridge:discoverRoots.state [${state?.length}]`);
+        const nodeManifest = state?.find(isPayloadOfSchemaType(NodeManifestPayloadSchema));
+        if (nodeManifest) {
+          const mods = (await this.resolveRootNode(nodeManifest)).filter(exists2);
+          this.logger?.debug(`HttpBridge:discoverRoots [${mods.length}]`);
+          this._roots = mods;
+        } else {
+          this._roots = [];
+        }
+      }
+      return this._roots;
+    });
+  }
+  moduleUrl(address) {
+    return new URL(address, this.clientUrl);
+  }
+  async sendBridgeQuery(targetAddress, query, payloads) {
+    const lastFailureTime = this._failureTimeCache.get(targetAddress);
+    if (lastFailureTime !== void 0) {
+      const now = Date.now();
+      const timeSincePreviousFailure = now - lastFailureTime;
+      if (timeSincePreviousFailure > this.failureRetryTime) {
+        throw new Error(`target module failed recently [${targetAddress}] [${timeSincePreviousFailure}ms ago]`);
+      }
+      this._failureTimeCache.delete(targetAddress);
+    }
+    try {
+      await this.querySemaphore.acquire();
+      const payloadSize = JSON.stringify([query, payloads]).length;
+      if (payloadSize > this.maxPayloadSizeWarning) {
+        this.logger?.warn(
+          `Large targetQuery being sent: ${payloadSize} bytes [${this.address}][${targetAddress}] [${query.schema}] [${payloads?.length ?? 0}]`
+        );
+      }
+      const moduleUrl = this.moduleUrl(targetAddress).href;
+      const result = await this.fetchClient.post(moduleUrl, [query, payloads]);
+      if (result.status === 404) {
+        throw new Error(`target module not found [${moduleUrl}] [${result.status}]`);
+      }
+      if (result.status >= 400) {
+        this.logger?.error(`targetQuery failed [${moduleUrl}]`);
+        throw new Error(`targetQuery failed [${moduleUrl}] [${result.status}]`);
+      }
+      return assertEx2(result.data?.data, () => `targetQuery returned no data [${moduleUrl}]`);
+    } catch (ex) {
+      const error = ex instanceof FetchClientError ? ex : ex;
+      this.logger?.error(`Error: ${toSafeJsonString(error)}`);
+      throw error;
+    } finally {
+      this.querySemaphore.release();
+    }
+  }
+  unexposeHandler(_id, _options) {
+    throw new Error("Unsupported");
+  }
+  async getRootState() {
+    const queryPayload = { schema: ModuleStateQuerySchema };
+    const boundQuery = await this.bindQuery(queryPayload);
+    try {
+      const response = await this.fetchClient.post(this.clientUrl.toString(), boundQuery);
+      if (response.status === 404) {
+        return [];
+      }
+      const [, payloads, errors] = response.data?.data ?? [void 0, [], []];
+      if (errors.length > 0) {
+        throw new Error(`getRootState failed: ${JSON.stringify(errors, null, 2)}`);
+      }
+      return payloads;
+    } catch (ex) {
+      const error = ex;
+      this.logger?.warn(`Unable to connect to remote node: ${error.message} [${this.clientUrl}]`);
+    }
+  }
+  async resolveRootNode(nodeManifest) {
+    const rootModule = assertEx2(
+      (await this.resolver.resolveHandler(
+        assertEx2(nodeManifest.status?.address, () => "Root has no address"),
+        void 0,
+        { manifest: nodeManifest }
+      )).at(0),
+      () => `Root not found [${nodeManifest.status?.address}]`
+    );
+    assertEx2(rootModule.constructor.name !== "HttpModuleProxy", () => "rootModule is not a Wrapper");
+    const rootNode = asAttachableNodeInstance(rootModule, "Root modules is not a node");
+    if (rootNode) {
+      this.logger?.debug(`rootNode: ${rootNode.id}`);
+      this.downResolver.addResolver(rootNode);
+      return [rootNode];
+    }
+    return [];
+  }
+};
+__publicField(HttpBridge, "configSchemas", [...__superGet(HttpBridge, HttpBridge, "configSchemas"), HttpBridgeConfigSchema]);
+__publicField(HttpBridge, "defaultConfigSchema", HttpBridgeConfigSchema);
+__publicField(HttpBridge, "defaultFailureRetryTime", 1e3 * 60);
+__publicField(HttpBridge, "defaultMaxConnections", 4);
+__publicField(HttpBridge, "defaultMaxPayloadSizeWarning", 256 * 256);
+__publicField(HttpBridge, "fetchClient", new FetchJsonClient());
+__publicField(HttpBridge, "maxFailureCacheSize", 1e3);
+HttpBridge = __decorateClass([
+  creatableModule2()
+], HttpBridge);
+export {
+  HttpBridge,
+  HttpBridgeConfigSchema,
+  HttpBridgeConfigZod,
+  asHttpBridgeConfig,
+  isHttpBridgeConfig,
+  toHttpBridgeConfig
+};

package/dist/_pkg/bridge-model/neutral/Config.d.ts

@@ -0,0 +1,33 @@
+import type { EmptyObject, WithAdditional } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { CacheConfig, ModuleConfig } from '../../module-model/neutral/index.ts';
+import { ModuleConfigZod } from '../../module-model/neutral/index.ts';
+import type { Payload, Schema } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const BridgeConfigSchema: 'network.xyo.bridge.config' & {
+    readonly __schema: true;
+};
+export type BridgeConfigSchema = typeof BridgeConfigSchema;
+export interface BridgeClientConfig {
+    cache?: CacheConfig | true;
+    discoverRoots?: 'start' | 'lazy';
+    maxDepth?: number;
+}
+export interface BridgeHostConfig {
+    cache?: CacheConfig | true;
+    maxDepth?: number;
+}
+export declare const BridgeConfigZod: z.ZodMiniObject<Omit<(typeof ModuleConfigZod)['shape'], 'schema'> & {
+    client: z.ZodMiniOptional<z.ZodMiniCustom<BridgeClientConfig, BridgeClientConfig>>;
+    host: z.ZodMiniOptional<z.ZodMiniCustom<BridgeHostConfig, BridgeHostConfig>>;
+    schema: z.ZodMiniLiteral<BridgeConfigSchema>;
+}, z.core.$strip>;
+export type BridgeConfigBase = z.infer<typeof BridgeConfigZod>;
+export declare const isBridgeConfig: ReturnType<typeof zodIsFactory<BridgeConfigBase>>;
+export declare const asBridgeConfig: ReturnType<typeof zodAsFactory<BridgeConfigBase>>;
+export declare const toBridgeConfig: ReturnType<typeof zodToFactory<BridgeConfigBase>>;
+export type BridgeConfig<TConfig extends Payload | EmptyObject | void = void, TSchema extends Schema | void = void, TClient extends EmptyObject | void = void, THost extends EmptyObject | void = void> = ModuleConfig<WithAdditional<{
+    client?: WithAdditional<BridgeClientConfig, TClient>;
+    host?: WithAdditional<BridgeHostConfig, THost>;
+    schema: TConfig extends Payload ? TConfig['schema'] : BridgeConfigSchema;
+}, TConfig>, TSchema>;

package/dist/_pkg/bridge-model/neutral/EventData.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleEventData } from '../../module-model/neutral/index.ts';
+import type { ExposedEventData, QueryFulfillFinishedEventData, QueryFulfillStartedEventData, QuerySendFinishedEventData, QuerySendStartedEventData, UnexposedEventData } from './Events/index.ts';
+export interface BridgeModuleEventData extends QuerySendFinishedEventData, QuerySendStartedEventData, QueryFulfillFinishedEventData, QueryFulfillStartedEventData, ExposedEventData, UnexposedEventData, ModuleEventData {
+}

package/dist/_pkg/bridge-model/neutral/Events/Exposed.d.ts

@@ -0,0 +1,8 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, ModuleInstance, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type ExposedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    modules: ModuleInstance[];
+}>;
+export interface ExposedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    exposed: ExposedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/QueryFulfillFinished.d.ts

@@ -0,0 +1,12 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, ModuleQueryResult, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, QueryBoundWitness } from '../../../sdk-protocol/neutral/index.ts';
+export type QueryFulfillFinishedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    payloads?: Payload[];
+    query: QueryBoundWitness;
+    result?: ModuleQueryResult;
+    status: 'success' | 'failure';
+}>;
+export interface QueryFulfillFinishedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    queryFulfillFinished: QueryFulfillFinishedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/QueryFulfillStarted.d.ts

@@ -0,0 +1,10 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, QueryBoundWitness } from '../../../sdk-protocol/neutral/index.ts';
+export type QueryFulfillStartedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    payloads?: Payload[];
+    query: QueryBoundWitness;
+}>;
+export interface QueryFulfillStartedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    queryFulfillStarted: QueryFulfillStartedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/QuerySendFinished.d.ts

@@ -0,0 +1,12 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, ModuleQueryResult, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, QueryBoundWitness } from '../../../sdk-protocol/neutral/index.ts';
+export type QuerySendFinishedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    payloads?: Payload[];
+    query: QueryBoundWitness;
+    result?: ModuleQueryResult;
+    status: 'success' | 'failure';
+}>;
+export interface QuerySendFinishedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    querySendFinished: QuerySendFinishedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/QuerySendStarted.d.ts

@@ -0,0 +1,10 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+import type { Payload, QueryBoundWitness } from '../../../sdk-protocol/neutral/index.ts';
+export type QuerySendStartedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    payloads?: Payload[];
+    query: QueryBoundWitness;
+}>;
+export interface QuerySendStartedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    querySendStarted: QuerySendStartedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/Unexposed.d.ts

@@ -0,0 +1,8 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, ModuleInstance, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type UnexposedEventArgs<T extends QueryableModule = QueryableModule> = ModuleEventArgs<T, {
+    modules: ModuleInstance[];
+}>;
+export interface UnexposedEventData<T extends QueryableModule = QueryableModule> extends EventData {
+    unexposed: UnexposedEventArgs<T>;
+}

package/dist/_pkg/bridge-model/neutral/Events/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Exposed.ts';
+export * from './QueryFulfillFinished.ts';
+export * from './QueryFulfillStarted.ts';
+export * from './QuerySendFinished.ts';
+export * from './QuerySendStarted.ts';
+export * from './Unexposed.ts';

package/dist/_pkg/bridge-model/neutral/Instance.d.ts

@@ -0,0 +1,10 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import type { BridgeModuleEventData } from './EventData.ts';
+import type { BridgeModule } from './Module.ts';
+import type { BridgeParams } from './Params.ts';
+import type { BridgeQueryFunctions } from './QueryFunctions.ts';
+export interface BridgeInstance<TParams extends BridgeParams = BridgeParams, TEventData extends BridgeModuleEventData = BridgeModuleEventData> extends BridgeModule<TParams, TEventData>, BridgeQueryFunctions, ModuleInstance<TParams, TEventData> {
+    exposed?: () => Promisable<XyoAddress[]>;
+}

package/dist/_pkg/bridge-model/neutral/Module.d.ts

@@ -0,0 +1,5 @@
+import type { QueryableModule } from '../../module-model/neutral/index.ts';
+import type { BridgeModuleEventData } from './EventData.ts';
+import type { BridgeParams } from './Params.ts';
+export interface BridgeModule<TParams extends BridgeParams = BridgeParams, TEventData extends BridgeModuleEventData = BridgeModuleEventData> extends QueryableModule<TParams, TEventData> {
+}

package/dist/_pkg/bridge-model/neutral/Params.d.ts

@@ -0,0 +1,5 @@
+import type { AnyConfigSchema, ModuleResolverInstance, QueryableModuleParams } from '../../module-model/neutral/index.ts';
+import type { BridgeConfig } from './Config.ts';
+export interface BridgeParams<TConfig extends AnyConfigSchema<BridgeConfig> = AnyConfigSchema<BridgeConfig>> extends QueryableModuleParams<TConfig>, QueryableModuleParams<TConfig> {
+    resolver?: ModuleResolverInstance;
+}

package/dist/_pkg/bridge-model/neutral/Queries/Connect.d.ts

@@ -0,0 +1,18 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const BridgeConnectQuerySchema: 'network.xyo.query.bridge.connect' & {
+    readonly __schema: true;
+};
+export type BridgeConnectQuerySchema = typeof BridgeConnectQuerySchema;
+export declare const BridgeConnectQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<BridgeConnectQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    id: z.ZodMiniOptional<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>;
+    maxDepth: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+export type BridgeConnectQuery = z.infer<typeof BridgeConnectQueryZod>;
+export declare const isBridgeConnectQuery: ReturnType<typeof zodIsFactory<BridgeConnectQuery>>;
+export declare const asBridgeConnectQuery: ReturnType<typeof zodAsFactory<BridgeConnectQuery>>;
+export declare const toBridgeConnectQuery: ReturnType<typeof zodToFactory<BridgeConnectQuery>>;

package/dist/_pkg/bridge-model/neutral/Queries/Disconnect.d.ts

@@ -0,0 +1,18 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const BridgeDisconnectQuerySchema: 'network.xyo.query.bridge.disconnect' & {
+    readonly __schema: true;
+};
+export type BridgeDisconnectQuerySchema = typeof BridgeDisconnectQuerySchema;
+export declare const BridgeDisconnectQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<BridgeDisconnectQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    id: z.ZodMiniOptional<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>;
+    maxDepth: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+export type BridgeDisconnectQuery = z.infer<typeof BridgeDisconnectQueryZod>;
+export declare const isBridgeDisconnectQuery: ReturnType<typeof zodIsFactory<BridgeDisconnectQuery>>;
+export declare const asBridgeDisconnectQuery: ReturnType<typeof zodAsFactory<BridgeDisconnectQuery>>;
+export declare const toBridgeDisconnectQuery: ReturnType<typeof zodToFactory<BridgeDisconnectQuery>>;

package/dist/_pkg/bridge-model/neutral/Queries/Expose.d.ts

@@ -0,0 +1,33 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const BridgeExposeQuerySchema: 'network.xyo.query.bridge.expose' & {
+    readonly __schema: true;
+};
+export type BridgeExposeQuerySchema = typeof BridgeExposeQuerySchema;
+export interface BridgeExposeOptions {
+    maxDepth?: number;
+    required?: boolean;
+}
+export declare const ModuleFilterPayloadSchema: 'network.xyo.module.filter' & {
+    readonly __schema: true;
+};
+export type ModuleFilterPayloadSchema = typeof ModuleFilterPayloadSchema;
+export declare const ModuleFilterPayloadZod: z.ZodMiniObject<{
+    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+    maxDepth: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    schema: z.ZodMiniLiteral<ModuleFilterPayloadSchema>;
+}, z.core.$strip>;
+export type ModuleFilterPayload = z.infer<typeof ModuleFilterPayloadZod>;
+export declare const isModuleFilterPayload: ReturnType<typeof zodIsFactory<ModuleFilterPayload>>;
+export declare const asModuleFilterPayload: ReturnType<typeof zodAsFactory<ModuleFilterPayload>>;
+export declare const toModuleFilterPayload: ReturnType<typeof zodToFactory<ModuleFilterPayload>>;
+export declare const BridgeExposeQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<BridgeExposeQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
+export type BridgeExposeQuery = z.infer<typeof BridgeExposeQueryZod>;
+export declare const isBridgeExposeQuery: ReturnType<typeof zodIsFactory<BridgeExposeQuery>>;
+export declare const asBridgeExposeQuery: ReturnType<typeof zodAsFactory<BridgeExposeQuery>>;
+export declare const toBridgeExposeQuery: ReturnType<typeof zodToFactory<BridgeExposeQuery>>;

package/dist/_pkg/bridge-model/neutral/Queries/Unexpose.d.ts

@@ -0,0 +1,17 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import type { BridgeExposeOptions } from './Expose.ts';
+export declare const BridgeUnexposeQuerySchema: 'network.xyo.query.bridge.unexpose' & {
+    readonly __schema: true;
+};
+export type BridgeUnexposeQuerySchema = typeof BridgeUnexposeQuerySchema;
+export interface BridgeUnexposeOptions extends BridgeExposeOptions {
+}
+export declare const BridgeUnexposeQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<BridgeUnexposeQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
+export type BridgeUnexposeQuery = z.infer<typeof BridgeUnexposeQueryZod>;
+export declare const isBridgeUnexposeQuery: ReturnType<typeof zodIsFactory<BridgeUnexposeQuery>>;
+export declare const asBridgeUnexposeQuery: ReturnType<typeof zodAsFactory<BridgeUnexposeQuery>>;
+export declare const toBridgeUnexposeQuery: ReturnType<typeof zodToFactory<BridgeUnexposeQuery>>;

package/dist/_pkg/bridge-model/neutral/Queries/index.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleQueries } from '../../../module-model/neutral/index.ts';
+import type { BridgeConnectQuery } from './Connect.ts';
+import type { BridgeDisconnectQuery } from './Disconnect.ts';
+import type { BridgeExposeQuery } from './Expose.ts';
+import type { BridgeUnexposeQuery } from './Unexpose.ts';
+export * from './Connect.ts';
+export * from './Disconnect.ts';
+export * from './Expose.ts';
+export * from './Unexpose.ts';
+export type BridgeQueries = BridgeConnectQuery | BridgeDisconnectQuery | BridgeExposeQuery | BridgeUnexposeQuery;
+export type BridgeModuleQueries = ModuleQueries | BridgeQueries;

package/dist/_pkg/bridge-model/neutral/QueryFunctions.d.ts

@@ -0,0 +1,10 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleIdentifier, ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import type { BridgeExposeOptions, BridgeUnexposeOptions } from './Queries/index.ts';
+export interface BridgeQueryFunctions {
+    connect?: (id: ModuleIdentifier, maxDepth?: number) => Promisable<XyoAddress | undefined>;
+    disconnect?: (id: ModuleIdentifier, maxDepth?: number) => Promisable<XyoAddress | undefined>;
+    expose: (id: ModuleIdentifier, options?: BridgeExposeOptions) => Promisable<ModuleInstance[]>;
+    unexpose?: (id: ModuleIdentifier, options?: BridgeUnexposeOptions) => Promisable<XyoAddress[]>;
+}

package/dist/_pkg/bridge-model/neutral/RawQueryFunctions.d.ts

@@ -0,0 +1,9 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleIdentifier, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import type { BridgeExposeOptions, BridgeUnexposeOptions } from './Queries/index.ts';
+export interface BridgeRawQueryFunctions {
+    connectQuery?: (id: ModuleIdentifier, maxDepth?: number) => Promisable<ModuleQueryResult>;
+    disconnectQuery?: (id: ModuleIdentifier, maxDepth?: number) => Promisable<ModuleQueryResult>;
+    exposeQuery: (id: ModuleIdentifier, options?: BridgeExposeOptions) => Promisable<ModuleQueryResult>;
+    unexposeQuery?: (id: ModuleIdentifier, options?: BridgeUnexposeOptions) => Promisable<ModuleQueryResult>;
+}