@xyo-network/sdk 7.0.2 → 7.0.4

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

@@ -1,537 +0,0 @@
-// src/AbstractBridge.ts
-import {
-  assertEx,
-  exists,
-  forget,
-  globallyUnique
-} from "@xylabs/sdk";
-import { asArchivistInstance } from "../../archivist-model/neutral/index.mjs";
-import {
-  BridgeConfigSchema,
-  BridgeConnectQuerySchema,
-  BridgeDisconnectQuerySchema,
-  BridgeExposeQuerySchema,
-  BridgeUnexposeQuerySchema,
-  ModuleFilterPayloadSchema
-} from "../../bridge-model/neutral/index.mjs";
-import { AbstractModuleInstance } from "../../module-abstract/neutral/index.mjs";
-import { AddressSchema } from "../../module-model/neutral/index.mjs";
-import {
-  resolveAddressToInstance,
-  resolvePathToAddress,
-  transformModuleIdentifier
-} from "../../module-resolver/neutral/index.mjs";
-import { isPayloadOfSchemaType, QueryBoundWitnessWrapper } from "../../sdk-protocol/neutral/index.mjs";
-var AbstractBridge = class _AbstractBridge extends AbstractModuleInstance {
-  static configSchemas = [...super.configSchemas, BridgeConfigSchema];
-  static defaultConfigSchema = BridgeConfigSchema;
-  static uniqueName = globallyUnique("AbstractBridge", _AbstractBridge, "xyo");
-  _roots;
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true;
-  }
-  get discoverRoots() {
-    return this.config.client?.discoverRoots ?? (this.config.client === void 0 ? false : "start");
-  }
-  get queries() {
-    return [BridgeConnectQuerySchema, BridgeDisconnectQuerySchema, BridgeExposeQuerySchema, BridgeUnexposeQuerySchema, ...super.queries];
-  }
-  get resolver() {
-    return assertEx(this.params.resolver, () => "No resolver provided");
-  }
-  async expose(id, options) {
-    this._noOverride("expose");
-    assertEx(id !== "*", () => "Exposing '*' not supported");
-    const addressToExpose = assertEx(await resolvePathToAddress(this, id), () => `Module to expose not found [${id}]`);
-    console.log(`expose: ${addressToExpose}`);
-    const modules = await this.exposeHandler(addressToExpose, options);
-    await this.emit("exposed", { mod: this, modules });
-    return modules;
-  }
-  async exposed() {
-    this._noOverride("exposed");
-    return await this.exposedHandler();
-  }
-  async resolve(id = "*", options = {}) {
-    const roots = this._roots ?? [];
-    const workingSet = options.direction === "up" ? [this] : [...roots, this];
-    if (id === "*") {
-      const remainingDepth = (options.maxDepth ?? 5) - 1;
-      return remainingDepth <= 0 ? workingSet : (
-        // eslint-disable-next-line @typescript-eslint/await-thenable
-        [...workingSet, ...(await Promise.all(roots.map((mod) => mod.resolve("*", { ...options, maxDepth: remainingDepth })))).flat()]
-      );
-    }
-    switch (typeof id) {
-      case "string": {
-        const parts = id.split(":");
-        const first = assertEx(parts.shift(), () => "Missing module identifier");
-        const firstId = await transformModuleIdentifier(first, this.moduleIdentifierTransformers);
-        const result = workingSet.find((mod) => {
-          return firstId === mod.address || firstId === mod.modName;
-        });
-        return parts.length === 0 ? result : result?.resolve(parts.join(":"), options);
-      }
-      default: {
-        return;
-      }
-    }
-  }
-  async startHandler() {
-    if (this.discoverRoots === "lazy") {
-      forget(this.getRoots());
-    } else if (this.discoverRoots === "start") {
-      await this.getRoots();
-    }
-  }
-  async unexpose(id, options) {
-    this._noOverride("unexpose");
-    const addressToUnexpose = assertEx(await resolvePathToAddress(this, id), () => `Module to unexpose not found [${id}]`);
-    const modules = await this.unexposeHandler(addressToUnexpose, options);
-    await this.emit("unexposed", { mod: this, modules });
-    return modules.map((mod) => mod.address);
-  }
-  async queryHandler(query, payloads) {
-    const wrapper = QueryBoundWitnessWrapper.parseQuery(query, payloads);
-    const queryPayload = await wrapper.getQuery();
-    const resultPayloads = [];
-    switch (queryPayload.schema) {
-      case BridgeExposeQuerySchema: {
-        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
-        assertEx(filterPayloads, () => "At least one filter is required");
-        await Promise.all(
-          filterPayloads.map(async (filter) => {
-            const { id, ...options } = filter;
-            const modules = await this.expose(id, options);
-            for (const mod of modules) {
-              const addressPayload = {
-                address: mod.address,
-                schema: AddressSchema
-              };
-              resultPayloads.push(addressPayload);
-            }
-          })
-        );
-        break;
-      }
-      case BridgeUnexposeQuerySchema: {
-        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
-        assertEx(filterPayloads, () => "At least one filter is required");
-        await Promise.all(
-          filterPayloads.map(async (filter) => {
-            const { id, ...options } = filter;
-            const moduleAddresses = await this.unexpose(id, options);
-            for (const address of moduleAddresses) {
-              const addressPayload = {
-                address,
-                schema: AddressSchema
-              };
-              resultPayloads.push(addressPayload);
-            }
-          })
-        );
-        break;
-      }
-      default: {
-        return await super.queryHandler(query, payloads);
-      }
-    }
-    return resultPayloads;
-  }
-  async resolveArchivingArchivists() {
-    const archivists = this.archiving?.archivists;
-    if (!archivists) return [];
-    const resolvedAddresses = (await Promise.all(
-      archivists.map(async (archivist) => (await Promise.all((await this.parents()).map((parent) => resolvePathToAddress(parent, archivist)))).filter(exists))
-    )).flat().filter(exists);
-    const resolved = (await Promise.all(resolvedAddresses.map((address) => resolveAddressToInstance(this, address)))).filter(exists);
-    return resolved.map((mod) => asArchivistInstance(mod)).filter(exists);
-  }
-};
-
-// src/AbstractBridgeModuleResolver.ts
-import { ObjectResolverPriority } from "../../module-model/neutral/index.mjs";
-import { CompositeModuleResolver } from "../../module-resolver/neutral/index.mjs";
-var AbstractBridgeModuleResolver = class extends CompositeModuleResolver {
-  get priority() {
-    return ObjectResolverPriority.VeryLow;
-  }
-  async resolveHandler(id, options, _params) {
-    if (id === "*") {
-      return [];
-    }
-    return await super.resolveHandler(id, options);
-  }
-};
-
-// src/AbstractModuleProxy/AbstractModuleProxy.ts
-import {
-  asAddress,
-  assertEx as assertEx3,
-  exists as exists3,
-  forget as forget2,
-  isAddress,
-  toSafeJsonString
-} from "@xylabs/sdk";
-import { AbstractModuleInstance as AbstractModuleInstance2 } from "../../module-abstract/neutral/index.mjs";
-import {
-  AddressPreviousHashSchema,
-  DeadModuleError,
-  ModuleAddressQuerySchema,
-  ModuleConfigSchema,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema
-} from "../../module-model/neutral/index.mjs";
-import { ModuleWrapper } from "../../module-wrapper/neutral/index.mjs";
-import {
-  Account as Account2,
-  BoundWitnessWrapper,
-  isPayloadOfSchemaType as isPayloadOfSchemaType2,
-  isSchema,
-  ModuleErrorSchema,
-  ModuleManifestPayloadSchema,
-  NodeManifestPayloadSchema,
-  PayloadBuilder,
-  QueryBoundWitnessWrapper as QueryBoundWitnessWrapper2,
-  QuerySchema
-} from "../../sdk-protocol/neutral/index.mjs";
-import { LRUCache } from "lru-cache";
-
-// src/AbstractModuleProxy/ModuleProxyResolver.ts
-import { assertEx as assertEx2, exists as exists2 } from "@xylabs/sdk";
-import { ObjectResolverPriority as ObjectResolverPriority2 } from "../../module-model/neutral/index.mjs";
-import { CompositeModuleResolver as CompositeModuleResolver2 } from "../../module-resolver/neutral/index.mjs";
-import { Account } from "../../sdk-protocol/neutral/index.mjs";
-
-// src/wrapModuleWithType.ts
-import { isArchivistModule } from "../../archivist-model/neutral/index.mjs";
-import { ArchivistWrapper } from "../../archivist-wrapper/neutral/index.mjs";
-import { isDivinerModule } from "../../diviner-model/neutral/index.mjs";
-import { DivinerWrapper } from "../../diviner-wrapper/neutral/index.mjs";
-import { isNodeModule } from "../../node-model/neutral/index.mjs";
-import { NodeWrapper } from "../../node-wrapper/neutral/index.mjs";
-import { isSentinelModule } from "../../sentinel-model/neutral/index.mjs";
-import { SentinelWrapper } from "../../sentinel-wrapper/neutral/index.mjs";
-import { isWitnessModule } from "../../witness-model/neutral/index.mjs";
-import { WitnessWrapper } from "../../witness-wrapper/neutral/index.mjs";
-var wrapModuleWithType = (mod, account) => {
-  if (isArchivistModule(mod)) {
-    return ArchivistWrapper.wrap(mod, account);
-  }
-  if (isDivinerModule(mod)) {
-    return DivinerWrapper.wrap(mod, account);
-  }
-  if (isNodeModule(mod)) {
-    return NodeWrapper.wrap(mod, account);
-  }
-  if (isSentinelModule(mod)) {
-    return SentinelWrapper.wrap(mod, account);
-  }
-  if (isWitnessModule(mod)) {
-    return WitnessWrapper.wrap(mod, account);
-  }
-  throw new Error("Failed to wrap");
-};
-
-// src/AbstractModuleProxy/ModuleProxyResolver.ts
-var ModuleProxyResolver = class {
-  downResolver;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.downResolver = new CompositeModuleResolver2({ moduleIdentifierTransformers: options.moduleIdentifierTransformers, root: this.root });
-  }
-  get priority() {
-    return ObjectResolverPriority2.VeryLow;
-  }
-  get root() {
-    return this.options.mod;
-  }
-  get childAddressMap() {
-    return this.options.childAddressMap;
-  }
-  get host() {
-    return this.options.host;
-  }
-  get mod() {
-    return this.options.mod;
-  }
-  addResolver(_resolver) {
-    throw new Error("Not supported");
-  }
-  childManifest(address) {
-    return this.options.childManifests?.[address];
-  }
-  childState(address) {
-    return this.options.childStates?.[address];
-  }
-  removeResolver(_resolver) {
-    throw new Error("Not supported");
-  }
-  // eslint-disable-next-line complexity
-  async resolve(id = "*", options) {
-    const direction = options?.direction ?? "all";
-    if (id === "*") {
-      const childAddresses = Object.keys(this.childAddressMap);
-      const resolvedChildren = await Promise.all(childAddresses.map((address) => this.resolve(address, options)));
-      return resolvedChildren.filter(exists2);
-    } else if (typeof id === "string") {
-      const idParts = id.split(":");
-      const firstPart = assertEx2(idParts.shift(), () => "Invalid module identifier at first position");
-      const firstPartAddress = await this.resolveIdentifier(firstPart);
-      if (firstPartAddress) {
-        const remainingParts = idParts.length > 0 ? idParts.join(":") : void 0;
-        if (direction === "down" || direction === "all") {
-          const downResolverModule = await this.downResolver.resolve(firstPartAddress);
-          if (downResolverModule) {
-            return remainingParts ? downResolverModule.resolve(remainingParts, options) : downResolverModule;
-          }
-          console.log(`ModuleProxyResolver: ${firstPartAddress} | ${this.root.address}`);
-          if (firstPartAddress === this.root.address) {
-            const wrapped = wrapModuleWithType(this.root, await Account.random());
-            return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
-          }
-          const addressToProxy = Object.keys(this.childAddressMap).includes(firstPartAddress) ? firstPartAddress : Object.entries(this.childAddressMap).find(([_, value]) => value === firstPartAddress)?.[0];
-          if (addressToProxy) {
-            const proxy = await this.host.resolve(addressToProxy, { ...options, direction: "down" });
-            if (proxy) {
-              const wrapped = wrapModuleWithType(proxy, await Account.random());
-              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
-            }
-            return;
-          }
-        }
-      }
-      return;
-    }
-  }
-  resolveIdentifier(id, _options) {
-    if (this.childAddressMap[id]) {
-      return id;
-    }
-    if (this.root.address === id) {
-      return this.root.address;
-    }
-    if (this.root.modName === id) {
-      return this.root.address;
-    }
-    const addressFromName = Object.entries(this.childAddressMap).find(([, name]) => name === id)?.[0];
-    if (addressFromName) {
-      return addressFromName;
-    }
-  }
-  async resolvePrivate(id, _options) {
-    if (id === "*") return await Promise.resolve([]);
-  }
-};
-
-// src/AbstractModuleProxy/AbstractModuleProxy.ts
-var AbstractModuleProxy = class extends AbstractModuleInstance2 {
-  static requiredQueries = [ModuleStateQuerySchema];
-  _config;
-  _publicChildren;
-  _state = void 0;
-  _stateInProcess = false;
-  _spamTrap = new LRUCache({
-    max: 1e3,
-    ttl: 1e3 * 60,
-    ttlAutopurge: true
-  });
-  get address() {
-    return this.params.moduleAddress;
-  }
-  get archiving() {
-    return this.params?.archiving;
-  }
-  get config() {
-    return { ...this._config, schema: this._config?.schema ?? ModuleConfigSchema };
-  }
-  get queries() {
-    const queryPayloads = assertEx3(this._state, () => "Module state not found.  Make sure proxy has been started").filter((item) => isPayloadOfSchemaType2(QuerySchema)(item));
-    return queryPayloads.map((payload) => payload.query);
-  }
-  static hasRequiredQueries(mod) {
-    return this.missingRequiredQueries(mod).length === 0;
-  }
-  static isAllowedSchema(schema) {
-    return isSchema(schema);
-  }
-  static missingRequiredQueries(mod) {
-    const moduleQueries = mod.queries;
-    return this.requiredQueries.map((query) => {
-      return moduleQueries.includes(query) ? null : query;
-    }).filter(exists3);
-  }
-  static async paramsHandler(inParams) {
-    const superParams = await super.paramsHandler(inParams);
-    return {
-      ...superParams,
-      account: superParams.account === "random" ? await Account2.random() : superParams.account,
-      addToResolvers: superParams.addToResolvers ?? true
-    };
-  }
-  async addressPreviousHash() {
-    const queryPayload = { schema: ModuleAddressQuerySchema };
-    const result = assertEx3(
-      (await this.sendQuery(queryPayload, void 0, this.account)).find(
-        isPayloadOfSchemaType2(AddressPreviousHashSchema)
-      ),
-      () => "Result did not include correct payload"
-    );
-    return result;
-  }
-  childAddressByName(name) {
-    const nodeManifests = this._state?.filter(isPayloadOfSchemaType2(NodeManifestPayloadSchema));
-    const childPairs = nodeManifests?.flatMap((nodeManifest) => Object.entries(nodeManifest.status?.children ?? {}));
-    return asAddress(childPairs?.find(([_, childName]) => childName === name)?.[0]);
-  }
-  async childAddressMap() {
-    let nodeManifests = isPayloadOfSchemaType2(NodeManifestPayloadSchema)(this.params.manifest) ? [this.params.manifest] : void 0;
-    const result = {};
-    if (nodeManifests === void 0) {
-      const state = await this.state();
-      nodeManifests = state.filter(isPayloadOfSchemaType2(NodeManifestPayloadSchema));
-    }
-    for (const manifest of nodeManifests ?? []) {
-      const children = manifest.modules?.public ?? [];
-      for (const child of children) {
-        if (typeof child === "object") {
-          const address = child.status?.address;
-          if (isAddress(address)) {
-            result[address] = child.config.name ?? null;
-          }
-        }
-      }
-    }
-    return result;
-  }
-  async createHandler() {
-    await super.createHandler();
-    let manifest = this.params.manifest;
-    if (!manifest) {
-      const state = await this.state();
-      const manifestPayload = state.find(
-        (payload) => isPayloadOfSchemaType2(NodeManifestPayloadSchema)(payload) || isPayloadOfSchemaType2(ModuleManifestPayloadSchema)(payload)
-      );
-      manifest = assertEx3(manifestPayload, () => "Can't find manifest payload");
-    }
-    this.setConfig({ ...manifest.config });
-    this.downResolver.addResolver(
-      new ModuleProxyResolver({
-        childAddressMap: await this.childAddressMap(),
-        host: this.params.host,
-        mod: this,
-        moduleIdentifierTransformers: this.params.moduleIdentifierTransformers
-      })
-    );
-  }
-  async manifest(maxDepth) {
-    const queryPayload = { schema: ModuleManifestQuerySchema, ...maxDepth === void 0 ? {} : { maxDepth } };
-    return (await this.sendQuery(queryPayload))[0];
-  }
-  async moduleAddress() {
-    const queryPayload = { schema: ModuleAddressQuerySchema };
-    return await this.sendQuery(queryPayload);
-  }
-  async previousHash() {
-    const queryPayload = { schema: ModuleAddressQuerySchema };
-    return (await this.sendQuery(queryPayload)).pop().previousHash;
-  }
-  async publicChildren() {
-    this._publicChildren = this._publicChildren ?? await super.publicChildren();
-    return this._publicChildren;
-  }
-  async query(query, payloads) {
-    this._checkDead();
-    return await this.busy(async () => {
-      try {
-        await this.checkSpam(query);
-        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-          forget2(this.storeToArchivists([query, ...payloads ?? []]));
-        }
-        this.params.onQuerySendStarted?.({ payloads, query });
-        const result = await this.proxyQueryHandler(query, payloads);
-        this.params.onQuerySendFinished?.({
-          payloads,
-          query,
-          result,
-          status: "success"
-        });
-        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-          forget2(this.storeToArchivists(result.flat()));
-        }
-        forget2(this.emit("moduleQueried", {
-          mod: this,
-          payloads,
-          query,
-          result
-        }));
-        return result;
-      } catch (ex) {
-        this.params.onQuerySendFinished?.({
-          payloads,
-          query,
-          status: "failure"
-        });
-        const error = ex;
-        this._lastError = error;
-        const deadError = new DeadModuleError(this.address, error);
-        const errorPayload = {
-          message: deadError.message,
-          name: deadError.name,
-          schema: ModuleErrorSchema
-        };
-        const sourceQuery = assertEx3(QueryBoundWitnessWrapper2.unwrap(query), () => "Invalid query");
-        return await this.bindQueryResult(sourceQuery, [], void 0, [errorPayload]);
-      }
-    });
-  }
-  queryHandler(_query, _payloads, _queryConfig) {
-    throw new Error("queryHandler should never be called");
-  }
-  async queryable(_query, _payloads, _queryConfig) {
-    return await Promise.resolve(true);
-  }
-  async resolveArchivingArchivists() {
-    return await this.params.archiving?.resolveArchivists() ?? [];
-  }
-  setConfig(config) {
-    this._config = config;
-  }
-  setState(state) {
-    this._state = state;
-  }
-  async state() {
-    if (this._state === void 0) {
-      const stateQueryPayload = { query: ModuleStateQuerySchema, schema: QuerySchema };
-      const manifestQueryPayload = { query: ModuleManifestQuerySchema, schema: QuerySchema };
-      this._state = [stateQueryPayload, manifestQueryPayload];
-      const wrapper = ModuleWrapper.wrap(this, await Account2.random());
-      this._state = await wrapper.state();
-    }
-    return this._state;
-  }
-  filterErrors(result) {
-    const wrapper = BoundWitnessWrapper.wrap(result[0], result[1]);
-    return wrapper.payloadsBySchema(ModuleErrorSchema);
-  }
-  async startHandler() {
-    return await super.startHandler();
-  }
-  // this checks and warns if we are getting spammed by the same query
-  async checkSpam(query) {
-    const hash = await PayloadBuilder.hash(query);
-    const previousCount = this._spamTrap.get(hash) ?? 0;
-    if (previousCount > 0) {
-      this.logger?.warn(`Spam trap triggered for query: ${hash} from ${toSafeJsonString(query.addresses)}`);
-    }
-    this._spamTrap.set(hash, previousCount + 1);
-  }
-};
-export {
-  AbstractBridge,
-  AbstractBridgeModuleResolver,
-  AbstractModuleProxy,
-  ModuleProxyResolver,
-  wrapModuleWithType
-};

package/dist/_pkg/bridge-abstract/neutral/wrapModuleWithType.d.ts

@@ -1,4 +0,0 @@
-import type { QueryableModule } from '../../module-model/neutral/index.ts';
-import type { ModuleWrapper } from '../../module-wrapper/neutral/index.ts';
-import type { AccountInstance } from '../../sdk-protocol/neutral/index.ts';
-export declare const wrapModuleWithType: (mod: QueryableModule, account: AccountInstance) => ModuleWrapper;

package/dist/_pkg/bridge-http/neutral/HttpBridge.d.ts

@@ -1,42 +0,0 @@
-import type { Promisable } from '@xylabs/sdk';
-import { FetchJsonClient } from '@xylabs/sdk';
-import { AbstractBridge } from '../../bridge-abstract/neutral/index.ts';
-import type { BridgeExposeOptions, BridgeModule, BridgeParams, BridgeUnexposeOptions } from '../../bridge-model/neutral/index.ts';
-import type { AnyConfigSchema, ModuleInstance, ModuleQueryResult } from '../../module-model/neutral/index.ts';
-import type { Payload, QueryBoundWitness, Schema, XyoAddress } from '../../sdk-protocol/neutral/index.ts';
-import { Semaphore } from 'async-mutex';
-import type { HttpBridgeConfig } from './HttpBridgeConfig.ts';
-import { HttpBridgeModuleResolver } from './HttpBridgeModuleResolver.ts';
-import type { BridgeQuerySender } from './ModuleProxy/index.ts';
-export interface HttpBridgeParams extends BridgeParams<AnyConfigSchema<HttpBridgeConfig>> {
-    fetchClient?: FetchJsonClient;
-}
-export declare class HttpBridge<TParams extends HttpBridgeParams> extends AbstractBridge<TParams> implements BridgeModule<TParams>, BridgeQuerySender {
-    static readonly configSchemas: Schema[];
-    static readonly defaultConfigSchema: Schema;
-    static readonly defaultFailureRetryTime: number;
-    static readonly defaultMaxConnections = 4;
-    static readonly defaultMaxPayloadSizeWarning: number;
-    static readonly fetchClient: FetchJsonClient;
-    static readonly maxFailureCacheSize = 1000;
-    private _discoverRootsMutex;
-    private _failureTimeCache;
-    private _fetchClient?;
-    private _querySemaphore?;
-    private _resolver?;
-    get clientUrl(): string;
-    get failureRetryTime(): number;
-    get fetchClient(): FetchJsonClient;
-    get maxConnections(): number;
-    get maxPayloadSizeWarning(): number;
-    get querySemaphore(): Semaphore;
-    get resolver(): HttpBridgeModuleResolver;
-    exposeHandler(_id: string, _options?: BridgeExposeOptions): Promisable<ModuleInstance[]>;
-    exposedHandler(): Promisable<XyoAddress[]>;
-    getRoots(force?: boolean): Promise<ModuleInstance[]>;
-    moduleUrl(address: XyoAddress): URL;
-    sendBridgeQuery<TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(targetAddress: XyoAddress, query: TQuery, payloads?: TIn[]): Promise<ModuleQueryResult<TOut>>;
-    unexposeHandler(_id: string, _options?: BridgeUnexposeOptions): Promisable<ModuleInstance[]>;
-    private getRootState;
-    private resolveRootNode;
-}

package/dist/_pkg/bridge-http/neutral/HttpBridgeConfig.d.ts

@@ -1,44 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { BridgeClientConfig, BridgeConfig } from '../../bridge-model/neutral/index.ts';
-import { BridgeConfigZod } from '../../bridge-model/neutral/index.ts';
-import type { Schema } from '../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const HttpBridgeConfigSchema: 'network.xyo.bridge.http.config' & {
-    readonly __schema: true;
-};
-export type HttpBridgeConfigSchema = typeof HttpBridgeConfigSchema;
-export declare const HttpBridgeConfigZod: z.ZodMiniObject<Omit<(typeof BridgeConfigZod)['shape'], 'schema' | 'client' | 'host'> & {
-    client: z.ZodMiniOptional<z.ZodMiniCustom<BridgeClientConfig & {
-        url: string;
-    }, BridgeClientConfig & {
-        url: string;
-    }>>;
-    failureRetryTime: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    failureTimeCacheMax: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    host: z.ZodMiniOptional<z.ZodMiniCustom<{
-        port: number;
-    }, {
-        port: number;
-    }>>;
-    maxConnections: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    maxPayloadSizeWarning: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    schema: z.ZodMiniLiteral<HttpBridgeConfigSchema>;
-}, z.core.$strip>;
-export type HttpBridgeConfigBase = z.infer<typeof HttpBridgeConfigZod>;
-export declare const isHttpBridgeConfig: ReturnType<typeof zodIsFactory<HttpBridgeConfigBase>>;
-export declare const asHttpBridgeConfig: ReturnType<typeof zodAsFactory<HttpBridgeConfigBase>>;
-export declare const toHttpBridgeConfig: ReturnType<typeof zodToFactory<HttpBridgeConfigBase>>;
-export 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;
-    schema: HttpBridgeConfigSchema;
-} & TConfig, TSchema extends Schema ? TSchema : HttpBridgeConfigSchema>;

package/dist/_pkg/bridge-http/neutral/HttpBridgeModuleResolver.d.ts

@@ -1,24 +0,0 @@
-import type { BridgeModuleResolverParams } from '../../bridge-abstract/neutral/index.ts';
-import { AbstractBridgeModuleResolver } from '../../bridge-abstract/neutral/index.ts';
-import type { AnyConfigSchema, ModuleConfig, ModuleEventData, ModuleFilterOptions, ModuleIdentifier, ModuleInstance, QueryableModuleParams } from '../../module-model/neutral/index.ts';
-import type { XyoAddress, XyoQuantAddress } from '../../sdk-protocol/neutral/index.ts';
-import { Mutex } from 'async-mutex';
-import { LRUCache } from 'lru-cache';
-import type { BridgeQuerySender, HttpModuleProxyParams } from './ModuleProxy/index.ts';
-export interface HttpBridgeModuleResolverParams extends BridgeModuleResolverParams {
-    querySender: BridgeQuerySender;
-    rootUrl: string;
-}
-export declare class HttpBridgeModuleResolver<T extends HttpBridgeModuleResolverParams = HttpBridgeModuleResolverParams> extends AbstractBridgeModuleResolver<T> {
-    protected _resolvedCache: LRUCache<(Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }) | XyoQuantAddress, {
-        notFound: boolean;
-    } | ModuleInstance<QueryableModuleParams<AnyConfigSchema<ModuleConfig>>, ModuleEventData<object>>, unknown>;
-    protected _resolvedCacheMutex: Mutex;
-    get querySender(): BridgeQuerySender;
-    moduleUrl(address: XyoAddress): URL;
-    resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>, params?: Partial<HttpModuleProxyParams>): Promise<T[]>;
-}

package/dist/_pkg/bridge-http/neutral/ModuleProxy/ModuleProxy.d.ts

@@ -1,22 +0,0 @@
-import type { ModuleProxyParams } from '../../../bridge-abstract/neutral/index.ts';
-import { AbstractModuleProxy } from '../../../bridge-abstract/neutral/index.ts';
-import type { AttachableModuleInstance, ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleQueryResult } from '../../../module-model/neutral/index.ts';
-import type { Payload, QueryBoundWitness, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
-export interface BridgeQuerySender {
-    sendBridgeQuery: <TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(targetAddress: XyoAddress, query: TQuery, payloads?: TIn[]) => Promise<ModuleQueryResult<TOut>>;
-}
-export type HttpModuleProxyParams = ModuleProxyParams & {
-    querySender: BridgeQuerySender;
-};
-export declare class HttpModuleProxy<TWrappedModule extends ModuleInstance = ModuleInstance, TParams extends Omit<HttpModuleProxyParams, 'config'> & {
-    config: TWrappedModule['config'];
-} = Omit<HttpModuleProxyParams, 'config'> & {
-    config: TWrappedModule['config'];
-}> extends AbstractModuleProxy<TWrappedModule, TParams> implements AttachableModuleInstance<TParams, TWrappedModule['eventData']> {
-    proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult>;
-    publicChildren(): Promise<ModuleInstance[]>;
-    /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
-    resolve(): Promise<ModuleInstance[]>;
-    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
-    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
-}

package/dist/_pkg/bridge-http/neutral/ModuleProxy/index.d.ts

@@ -1 +0,0 @@
-export * from './ModuleProxy.ts';

package/dist/_pkg/bridge-http/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './HttpBridge.ts';
-export * from './HttpBridgeConfig.ts';