@xyo-network/sdk 7.0.3 → 7.0.5

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

@@ -1,380 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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>;
-}