@xyo-network/sdk 2.102.3 → 7.0.2

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

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

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

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

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

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

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

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

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

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