@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/boundwitness-wrapper/neutral/index.mjs

@@ -0,0 +1,280 @@
+// src/BoundWitnessWrapper.ts
+import {
+  asHash,
+  assertEx,
+  isNumber,
+  isObject
+} from "@xylabs/sdk";
+import {
+  asBoundWitness,
+  BoundWitnessSchema,
+  isBoundWitness
+} from "../../boundwitness-model/neutral/index.mjs";
+import { BoundWitnessValidator } from "../../boundwitness-validator/neutral/index.mjs";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import {
+  isPayloadWrapperBase,
+  PayloadWrapper,
+  PayloadWrapperBase
+} from "../../payload-wrapper/neutral/index.mjs";
+var isBoundWitnessWrapper = (value) => {
+  if (isPayloadWrapperBase(value)) {
+    return typeof value.payloadsDataHashMap === "function";
+  }
+  return false;
+};
+var BoundWitnessWrapper = class _BoundWitnessWrapper extends PayloadWrapperBase {
+  _payloadDataMap;
+  _payloadMap;
+  boundwitness;
+  moduleErrors;
+  payloads = [];
+  constructor(boundwitness, payloads = [], moduleErrors) {
+    super(boundwitness);
+    this.boundwitness = boundwitness;
+    this.payloads = payloads;
+    this.moduleErrors = moduleErrors;
+  }
+  static as(value) {
+    return value instanceof this ? value : void 0;
+  }
+  static async load(address) {
+    const wrapper = await PayloadWrapper.load(address);
+    const payload = wrapper?.payload;
+    assertEx(payload && isBoundWitness(payload), () => "Attempt to load non-boundwitness");
+    const boundWitness = payload && isBoundWitness(payload) ? payload : void 0;
+    return boundWitness ? this.wrap(boundWitness) : null;
+  }
+  static parse(obj, payloads) {
+    let hydratedObj;
+    switch (typeof obj) {
+      case "string": {
+        hydratedObj = JSON.parse(obj);
+        break;
+      }
+      case "object": {
+        if (isObject(obj)) {
+          hydratedObj = obj;
+        }
+        break;
+      }
+    }
+    if (hydratedObj) {
+      if (isBoundWitnessWrapper(hydratedObj)) {
+        return hydratedObj;
+      }
+      if (isBoundWitness(hydratedObj)) {
+        const wrapper = new _BoundWitnessWrapper(hydratedObj, payloads ?? []);
+        return wrapper;
+      }
+    }
+    throw new Error(`Unable to parse [${typeof obj}]`);
+  }
+  static tryParse(obj, payloads) {
+    if (obj === void 0) return void 0;
+    try {
+      return this.parse(obj, payloads);
+    } catch {
+      return void 0;
+    }
+  }
+  static wrap(obj, payloads) {
+    switch (typeof obj) {
+      case "object": {
+        if (obj instanceof this) {
+          return obj;
+        }
+        return obj instanceof PayloadWrapper && obj.schema() === BoundWitnessSchema ? this.parse(obj.payload, payloads) : this.parse(obj, payloads);
+      }
+    }
+  }
+  static async wrappedDataHashMap(boundWitnesses) {
+    const result = {};
+    await Promise.all(
+      boundWitnesses.map(async (payload) => {
+        const bw = this.parse(payload);
+        const dataHash = String(await bw.dataHash());
+        result[dataHash] = bw;
+      })
+    );
+    return result;
+  }
+  get addresses() {
+    return this.boundwitness.addresses;
+  }
+  get payloadHashes() {
+    return this.boundwitness.payload_hashes;
+  }
+  get payloadSchemas() {
+    return this.boundwitness.payload_schemas;
+  }
+  get previousHashes() {
+    return this.boundwitness.previous_hashes;
+  }
+  async dig(depth) {
+    if (depth === 0) return this;
+    const innerBoundwitnessIndex = this.payloadSchemas.indexOf(BoundWitnessSchema);
+    if (innerBoundwitnessIndex !== -1) {
+      const innerBoundwitnessHash = String(asHash(this.payloadHashes[innerBoundwitnessIndex], true));
+      const allHashMap = await PayloadBuilder.toAllHashMap(this.payloads);
+      const innerBoundwitnessPayload = asBoundWitness(
+        allHashMap[innerBoundwitnessHash]
+      );
+      const innerBoundwitness = innerBoundwitnessPayload ? new _BoundWitnessWrapper(innerBoundwitnessPayload, await PayloadBuilder.filterExclude(this.payloads, innerBoundwitnessHash)) : void 0;
+      if (innerBoundwitness) {
+        return innerBoundwitness.dig(isNumber(depth) ? depth - 1 : void 0);
+      }
+    }
+    assertEx(depth === 0, () => `Dig failed [Remaining Depth: ${depth}]`);
+    return this;
+  }
+  async getMissingPayloads() {
+    const payloadMap = await this.payloadsDataHashMap();
+    return this.payloadHashes.filter((hash) => {
+      const hashKey = String(asHash(hash, true));
+      return !Object.hasOwn(payloadMap, hashKey);
+    });
+  }
+  async getWrappedPayloads() {
+    return this.payloads.map((payload) => PayloadWrapper.wrap(payload));
+  }
+  hashesBySchema(schema) {
+    const result = [];
+    for (const [index, payloadSchema] of this.payloadSchemas.entries()) {
+      if (payloadSchema === schema) {
+        result.push(asHash(this.payloadHashes[index], true));
+      }
+    }
+    return result;
+  }
+  async payloadsByDataHashes(hashes) {
+    const map = await this.payloadsDataHashMap();
+    return hashes.map((hash) => {
+      const hashKey = String(hash);
+      return assertEx(map[hashKey], () => "Hash not found");
+    });
+  }
+  async payloadsByHashes(hashes) {
+    const map = await this.payloadsHashMap();
+    return hashes.map((hash) => {
+      const hashKey = String(hash);
+      return assertEx(map[hashKey], () => "Hash not found");
+    });
+  }
+  payloadsBySchema(schema) {
+    return this.payloads.filter((payload) => payload?.schema === schema);
+  }
+  async payloadsDataHashMap() {
+    this._payloadDataMap = this._payloadDataMap ?? await PayloadBuilder.toDataHashMap(this.payloads);
+    return this._payloadDataMap;
+  }
+  async payloadsHashMap() {
+    this._payloadMap = this._payloadMap ?? await PayloadBuilder.toHashMap(this.payloads);
+    return this._payloadMap;
+  }
+  prev(address) {
+    return this.previousHashes[this.addresses.indexOf(address)];
+  }
+  toResult() {
+    return [this.boundwitness, this.payloads];
+  }
+  async validate() {
+    const validator = new BoundWitnessValidator(this.boundwitness);
+    return await validator.validate();
+  }
+};
+
+// src/QueryBoundWitnessWrapper.ts
+import {
+  asHash as asHash2,
+  assertEx as assertEx2,
+  exists
+} from "@xylabs/sdk";
+import { isQueryBoundWitness } from "../../boundwitness-model/neutral/index.mjs";
+import { PayloadBuilder as PayloadBuilder2 } from "../../payload/neutral/index.mjs";
+import { PayloadWrapper as PayloadWrapper2 } from "../../payload-wrapper/neutral/index.mjs";
+var QueryBoundWitnessWrapper = class _QueryBoundWitnessWrapper extends BoundWitnessWrapper {
+  _payloadsWithoutQuery;
+  _query;
+  static parseQuery(obj, payloads) {
+    assertEx2(!Array.isArray(obj), () => "Array can not be converted to QueryBoundWitnessWrapper");
+    switch (typeof obj) {
+      case "object": {
+        const castWrapper = obj;
+        const result = castWrapper instanceof this ? castWrapper : isQueryBoundWitness(obj) ? new _QueryBoundWitnessWrapper(
+          obj,
+          payloads
+        ) : void 0;
+        if (result === void 0) {
+          throw new Error("Unable to parse. Failed isQueryBoundWitness.");
+        }
+        return result;
+      }
+    }
+    throw new Error(`Unable to parse [${typeof obj}]`);
+  }
+  static tryParseQuery(obj) {
+    if (obj === void 0) return void 0;
+    try {
+      return this.parseQuery(obj);
+    } catch {
+      return void 0;
+    }
+  }
+  async getPayloadsWithoutQuery() {
+    if (!this._payloadsWithoutQuery) {
+      const payloadsWithoutQuery = await PayloadBuilder2.filterExclude(this.payloads, asHash2(this.payload.query, true));
+      this._payloadsWithoutQuery = payloadsWithoutQuery.map((payload) => PayloadWrapper2.wrap(payload)).filter(exists);
+    }
+    return this._payloadsWithoutQuery;
+  }
+  async getQuery() {
+    const payloadMap = await this.payloadsDataHashMap();
+    const queryHash = String(asHash2(this.boundwitness.query, true));
+    this._query = this._query ?? payloadMap[queryHash];
+    return assertEx2(this._query, () => `Missing Query [${JSON.stringify(this.boundwitness)}]`);
+  }
+};
+
+// src/SchemaType.ts
+import { HashRegEx, HexRegExMinMax } from "@xylabs/sdk";
+import { XyoAddressRegEx } from "../../address/neutral/index.mjs";
+import { SchemaRegEx } from "../../payload-model/neutral/index.mjs";
+import { payloadJsonSchema } from "../../payload-wrapper/neutral/index.mjs";
+var SignatureRegEx = HexRegExMinMax(64, 5261);
+var boundWitnessProperties = {
+  ...payloadJsonSchema.properties,
+  addresses: { items: { type: "string", pattern: XyoAddressRegEx.source }, type: "array" },
+  payload_hashes: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  payload_schemas: { items: { type: "string", pattern: SchemaRegEx.source }, type: "array" },
+  previous_hashes: {
+    items: {
+      type: "string",
+      pattern: HashRegEx.source,
+      nullable: true
+    },
+    type: "array"
+  },
+  root: { type: "string", pattern: HashRegEx.source },
+  $destination: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  $sourceQuery: { type: "string", pattern: HashRegEx.source },
+  $sources: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  $signatures: { items: { type: "string", pattern: SignatureRegEx.source }, type: "array" }
+};
+var boundWitnessJsonSchema = {
+  ...payloadJsonSchema,
+  $id: "https://schemas.xyo.network/2.0/boundwitness",
+  additionalProperties: false,
+  properties: boundWitnessProperties,
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  required: [...payloadJsonSchema.required, "addresses", "payload_hashes", "payload_schemas", "previous_hashes"],
+  type: "object"
+};
+export {
+  BoundWitnessWrapper,
+  QueryBoundWitnessWrapper,
+  SignatureRegEx,
+  boundWitnessJsonSchema,
+  boundWitnessProperties,
+  isBoundWitnessWrapper
+};

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

@@ -0,0 +1,3 @@
+export * from '../../bridge-abstract/neutral/index.ts';
+export * from '../../bridge-model/neutral/index.ts';
+export * from '../../bridge-wrapper/neutral/index.ts';

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

@@ -0,0 +1,4 @@
+// src/index.ts
+export * from "../../bridge-abstract/neutral/index.mjs";
+export * from "../../bridge-model/neutral/index.mjs";
+export * from "../../bridge-wrapper/neutral/index.mjs";

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

@@ -0,0 +1 @@
+export * from '../../bridge-model/neutral/index.ts';

package/dist/_pkg/bridge/neutral/model.mjs

@@ -0,0 +1,2 @@
+// src/model.ts
+export * from "../../bridge-model/neutral/index.mjs";

package/dist/_pkg/bridge/neutral/wrapper.d.ts

@@ -0,0 +1 @@
+export * from '../../bridge-wrapper/neutral/index.ts';

package/dist/_pkg/bridge/neutral/wrapper.mjs

@@ -0,0 +1,2 @@
+// src/wrapper.ts
+export * from "../../bridge-wrapper/neutral/index.mjs";

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

@@ -0,0 +1,30 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { AttachableBridgeInstance, BridgeExposeOptions, BridgeModuleEventData, BridgeParams, BridgeUnexposeOptions } from '../../bridge-model/neutral/index.ts';
+import { AbstractModuleInstance } from '../../module-abstract/neutral/index.ts';
+import type { ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleQueryHandlerResult, ModuleResolverInstance } from '../../module-model/neutral/index.ts';
+import type { Payload, QueryBoundWitness, Schema, XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+export declare abstract class AbstractBridge<TParams extends BridgeParams = BridgeParams> extends AbstractModuleInstance<TParams, BridgeModuleEventData> implements AttachableBridgeInstance<TParams, BridgeModuleEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly uniqueName: string;
+    protected _roots?: ModuleInstance[];
+    get allowNameResolution(): boolean;
+    get discoverRoots(): false | 'start' | 'lazy';
+    get queries(): Schema[];
+    get resolver(): Promisable<ModuleResolverInstance>;
+    expose(id: ModuleIdentifier, options?: BridgeExposeOptions): Promise<ModuleInstance[]>;
+    exposed(): Promise<XyoAddress[]>;
+    /** @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>;
+    startHandler(): Promise<void>;
+    unexpose(id: ModuleIdentifier, options?: BridgeUnexposeOptions): Promise<XyoAddress[]>;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryHandlerResult>;
+    protected resolveArchivingArchivists(): Promise<ArchivistInstance[]>;
+    abstract exposeHandler(address: XyoAddress, options?: BridgeExposeOptions): Promisable<ModuleInstance[]>;
+    abstract exposedHandler(): Promisable<XyoAddress[]>;
+    abstract getRoots(force?: boolean): Promise<ModuleInstance[]>;
+    abstract unexposeHandler(address: XyoAddress, options?: BridgeUnexposeOptions): Promisable<ModuleInstance[]>;
+}

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

@@ -0,0 +1,22 @@
+import type { ArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { BridgeInstance, QuerySendFinishedEventArgs, QuerySendStartedEventArgs } from '../../bridge-model/neutral/index.ts';
+import type { ArchivingModuleConfig, CacheConfig, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '../../module-model/neutral/index.ts';
+import type { ModuleResolverParams } from '../../module-resolver/neutral/index.ts';
+import { CompositeModuleResolver } from '../../module-resolver/neutral/index.ts';
+import type { AccountInstance } from '../../sdk-protocol/neutral/index.ts';
+import type { ModuleProxyParams } from './AbstractModuleProxy/index.ts';
+export interface BridgeModuleResolverParams extends ModuleResolverParams {
+    additionalSigners?: AccountInstance[];
+    archiving?: ArchivingModuleConfig['archiving'] & {
+        resolveArchivists: () => Promise<ArchivistInstance[]>;
+    };
+    bridge: BridgeInstance;
+    cacheConfig?: CacheConfig;
+    onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void;
+    onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void;
+    wrapperAccount: AccountInstance;
+}
+export declare abstract class AbstractBridgeModuleResolver<TParams extends BridgeModuleResolverParams = BridgeModuleResolverParams, TProxyParams extends ModuleProxyParams = ModuleProxyParams> extends CompositeModuleResolver<TParams> {
+    get priority(): 0;
+    resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>, _params?: Partial<TProxyParams>): Promise<T[]>;
+}

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

@@ -0,0 +1,58 @@
+import type { ArchivistInstance } from '../../../archivist-model/neutral/index.ts';
+import type { QuerySendFinishedEventArgs, QuerySendStartedEventArgs } from '../../../bridge-model/neutral/index.ts';
+import { AbstractModuleInstance } from '../../../module-abstract/neutral/index.ts';
+import type { AddressPreviousHashPayload, AnyConfigSchema, ArchivingModuleConfig, AttachableModuleInstance, ModuleConfig, ModuleEventData, ModuleInstance, ModuleName, ModuleQueryHandlerResult, ModuleQueryResult, ModuleResolver, QueryableModule, QueryableModuleParams } from '../../../module-model/neutral/index.ts';
+import type { AccountInstance, ModuleError, ModuleManifestPayload, Payload, QueryBoundWitness, Schema, XyoAddress, XyoQuantAddress } from '../../../sdk-protocol/neutral/index.ts';
+export interface ModuleProxyParams extends QueryableModuleParams {
+    account: AccountInstance;
+    archiving?: ArchivingModuleConfig['archiving'] & {
+        resolveArchivists: () => Promise<ArchivistInstance[]>;
+    };
+    host: ModuleResolver;
+    manifest?: ModuleManifestPayload;
+    moduleAddress: XyoAddress;
+    onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void;
+    onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void;
+    state?: Payload[];
+}
+export declare abstract class AbstractModuleProxy<TWrappedModule extends ModuleInstance = ModuleInstance, TParams extends ModuleProxyParams = ModuleProxyParams> extends AbstractModuleInstance<TParams, TWrappedModule['eventData']> implements ModuleInstance<TParams, TWrappedModule['eventData']> {
+    static readonly requiredQueries: string[];
+    protected _config?: TWrappedModule['config'];
+    protected _publicChildren?: ModuleInstance[];
+    protected _state: Payload[] | undefined;
+    protected _stateInProcess: boolean;
+    private _spamTrap;
+    get address(): (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress;
+    get archiving(): ArchivingModuleConfig['archiving'] | undefined;
+    get config(): TWrappedModule['config'] & {
+        schema: Schema;
+    };
+    get queries(): Schema[];
+    static hasRequiredQueries(mod: QueryableModule): boolean;
+    static isAllowedSchema(schema: Schema): boolean;
+    static missingRequiredQueries(mod: QueryableModule): string[];
+    static paramsHandler<T extends AttachableModuleInstance<QueryableModuleParams, ModuleEventData>>(inParams?: Partial<T['params']>): Promise<T['params']>;
+    addressPreviousHash(): Promise<AddressPreviousHashPayload>;
+    childAddressByName(name: ModuleName): XyoAddress | undefined;
+    childAddressMap(): Promise<Record<XyoAddress, ModuleName | null>>;
+    createHandler(): Promise<void>;
+    manifest(maxDepth?: number): Promise<ModuleManifestPayload>;
+    moduleAddress(): Promise<AddressPreviousHashPayload[]>;
+    previousHash(): Promise<string | undefined>;
+    publicChildren(): Promise<ModuleInstance<QueryableModuleParams<AnyConfigSchema<ModuleConfig>>, ModuleEventData<object>>[]>;
+    query<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult>;
+    queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[], _queryConfig?: TWrappedModule['params']['config']): Promise<ModuleQueryHandlerResult>;
+    queryable<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[], _queryConfig?: TWrappedModule['params']['config']): Promise<boolean>;
+    resolveArchivingArchivists(): Promise<ArchivistInstance[]>;
+    setConfig(config: TWrappedModule['params']['config']): void;
+    setState(state: Payload[]): void;
+    state(): Promise<Payload[]>;
+    protected filterErrors(result: ModuleQueryResult): ModuleError[];
+    protected startHandler(): Promise<void>;
+    private checkSpam;
+    abstract proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[]): Promise<ModuleQueryResult>;
+}

package/dist/_pkg/bridge-abstract/neutral/AbstractModuleProxy/ModuleProxyResolver.d.ts

@@ -0,0 +1,36 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { AnyConfigSchema, ModuleConfig, ModuleEventData, ModuleFilterOptions, ModuleIdentifier, ModuleIdentifierTransformer, ModuleInstance, ModuleName, ModuleResolver, ModuleResolverInstance, ObjectFilterOptions, QueryableModuleParams } from '../../../module-model/neutral/index.ts';
+import type { ModuleManifestPayload, XyoAddress, XyoQuantAddress } from '../../../sdk-protocol/neutral/index.ts';
+export interface ModuleProxyResolverOptions {
+    childAddressMap: Record<XyoAddress, ModuleName | null>;
+    childManifests?: Record<XyoAddress, ModuleManifestPayload>;
+    childStates?: Record<XyoAddress, ModuleManifestPayload>;
+    host: ModuleResolver;
+    mod: ModuleInstance;
+    moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+}
+export declare class ModuleProxyResolver<T extends ModuleProxyResolverOptions = ModuleProxyResolverOptions> implements ModuleResolverInstance {
+    private downResolver;
+    private options;
+    constructor(options: T);
+    get priority(): 0;
+    get root(): ModuleInstance;
+    protected get childAddressMap(): Record<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress, string | null>;
+    protected get host(): ModuleResolver<ModuleInstance<QueryableModuleParams<AnyConfigSchema<ModuleConfig>>, ModuleEventData<object>>>;
+    protected get mod(): ModuleInstance;
+    addResolver(_resolver: ModuleResolver): this;
+    childManifest(address: XyoAddress): ModuleManifestPayload | undefined;
+    childState(address: XyoAddress): ModuleManifestPayload | undefined;
+    removeResolver(_resolver: ModuleResolver): this;
+    /** @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>;
+    resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<XyoAddress | undefined>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>;
+}

package/dist/_pkg/bridge-abstract/neutral/AbstractModuleProxy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AbstractModuleProxy.ts';
+export * from './ModuleProxyResolver.ts';

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

@@ -0,0 +1,4 @@
+export * from './AbstractBridge.ts';
+export * from './AbstractBridgeModuleResolver.ts';
+export * from './AbstractModuleProxy/index.ts';
+export * from './wrapModuleWithType.ts';