@xyo-network/sdk 7.0.2 → 7.0.4

package/dist/_pkg/manifest-model/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './Manifest.ts';
-export * from './Payload.ts';

package/dist/_pkg/manifest-model/neutral/index.mjs

@@ -1,192 +0,0 @@
-// src/Manifest.zod.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk";
-import * as z from "zod/mini";
-var isString = (value) => typeof value === "string";
-var stringZod = z.string();
-var optionalStringZod = z.optional(stringZod);
-var optionalStringArrayZod = z.optional(z.array(stringZod));
-var optionalStringRecordZod = z.optional(z.record(stringZod, optionalStringZod));
-var xyoAddressZod = z.custom(isString);
-var nullableStringZod = z.nullable(stringZod);
-var optionalAddressChildrenRecordZod = z.optional(z.record(xyoAddressZod, nullableStringZod));
-var schemaZod = z.custom(isString);
-var asBrandedZod = (schema) => {
-  return z.pipe(schema, z.transform((value) => value));
-};
-var ModuleAliasZod = asBrandedZod(z.string());
-var ManifestZod = z.object({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string())
-});
-var isManifest = zodIsFactory(ManifestZod);
-var asManifest = zodAsFactory(ManifestZod, "asManifest");
-var toManifest = zodToFactory(ManifestZod, "toManifest");
-var ConfigManifestZod = z.looseObject({
-  accountPath: optionalStringZod,
-  features: optionalStringArrayZod,
-  labels: optionalStringRecordZod,
-  language: optionalStringZod,
-  name: stringZod,
-  os: optionalStringZod,
-  schema: schemaZod
-});
-var isConfigManifest = zodIsFactory(ConfigManifestZod);
-var asConfigManifest = zodAsFactory(ConfigManifestZod, "asConfigManifest");
-var toConfigManifest = zodToFactory(ConfigManifestZod, "toConfigManifest");
-var ModuleManifestStatusZod = z.object({
-  address: xyoAddressZod,
-  children: optionalAddressChildrenRecordZod
-});
-var ModuleManifestZod = z.extend(ManifestZod, {
-  config: ConfigManifestZod,
-  lazyStart: z.optional(z.boolean()),
-  status: z.optional(ModuleManifestStatusZod)
-});
-var isModuleManifest = zodIsFactory(ModuleManifestZod);
-var asModuleManifest = zodAsFactory(ModuleManifestZod, "asModuleManifest");
-var toModuleManifest = zodToFactory(ModuleManifestZod, "toModuleManifest");
-var ModuleManifestReferenceZod = z.union([ModuleManifestZod, ModuleAliasZod]);
-var moduleManifestReferenceArrayZod = z.optional(z.array(ModuleManifestReferenceZod));
-var nodeModulesZod = z.optional(z.object({ private: moduleManifestReferenceArrayZod, public: moduleManifestReferenceArrayZod }));
-var NodeManifestZod = z.extend(ModuleManifestZod, { modules: nodeModulesZod });
-var isNodeManifest = zodIsFactory(NodeManifestZod);
-var asNodeManifest = zodAsFactory(NodeManifestZod, "asNodeManifest");
-var toNodeManifest = zodToFactory(NodeManifestZod, "toNodeManifest");
-var PackageManifestZod = z.extend(ManifestZod, {
-  modules: z.optional(z.record(ModuleAliasZod, ModuleManifestZod)),
-  nodes: z.array(NodeManifestZod)
-});
-var isPackageManifest = zodIsFactory(PackageManifestZod);
-var asPackageManifest = zodAsFactory(PackageManifestZod, "asPackageManifest");
-var toPackageManifest = zodToFactory(PackageManifestZod, "toPackageManifest");
-var AuthoredModuleManifestBaseZod = z.strictObject({
-  config: ConfigManifestZod,
-  description: z.optional(z.string())
-});
-var AuthoredModuleManifestZod = AuthoredModuleManifestBaseZod;
-var isAuthoredModuleManifest = zodIsFactory(AuthoredModuleManifestZod);
-var asAuthoredModuleManifest = zodAsFactory(AuthoredModuleManifestZod, "asAuthoredModuleManifest");
-var toAuthoredModuleManifest = zodToFactory(AuthoredModuleManifestZod, "toAuthoredModuleManifest");
-var authoredModuleManifestArrayZod = z.optional(z.array(AuthoredModuleManifestBaseZod));
-var authoredNodeModulesZod = z.optional(z.strictObject({
-  private: authoredModuleManifestArrayZod,
-  public: authoredModuleManifestArrayZod
-}));
-var AuthoredNodeManifestZod = z.extend(AuthoredModuleManifestBaseZod, {
-  modules: authoredNodeModulesZod,
-  name: optionalStringZod
-});
-var isAuthoredNodeManifest = zodIsFactory(AuthoredNodeManifestZod);
-var asAuthoredNodeManifest = zodAsFactory(AuthoredNodeManifestZod, "asAuthoredNodeManifest");
-var toAuthoredNodeManifest = zodToFactory(AuthoredNodeManifestZod, "toAuthoredNodeManifest");
-var AuthoredPackageManifestZod = z.strictObject({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string()),
-  nodes: z.array(AuthoredNodeManifestZod),
-  schema: z.literal("network.xyo.manifest")
-});
-var isAuthoredPackageManifest = zodIsFactory(AuthoredPackageManifestZod);
-var asAuthoredPackageManifest = zodAsFactory(AuthoredPackageManifestZod, "asAuthoredPackageManifest");
-var toAuthoredPackageManifest = zodToFactory(AuthoredPackageManifestZod, "toAuthoredPackageManifest");
-var ExternalModuleRequestZod = z.strictObject({ name: z.string() });
-var ExternalManifestZod = z.strictObject({ modules: z.array(ExternalModuleRequestZod) });
-var AuthoredDappPackageManifestZod = z.strictObject({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string()),
-  external: z.optional(ExternalManifestZod),
-  nodes: z.array(AuthoredNodeManifestZod),
-  schema: z.literal("network.xyo.manifest.package.dapp")
-});
-var isAuthoredDappPackageManifest = zodIsFactory(AuthoredDappPackageManifestZod);
-var asAuthoredDappPackageManifest = zodAsFactory(AuthoredDappPackageManifestZod, "asAuthoredDappPackageManifest");
-var toAuthoredDappPackageManifest = zodToFactory(AuthoredDappPackageManifestZod, "toAuthoredDappPackageManifest");
-
-// src/Payload.zod.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import { asSchema } from "../../payload-model/neutral/index.mjs";
-import * as z2 from "zod/mini";
-var DappPackageManifestPayloadSchema = asSchema("network.xyo.manifest.package.dapp", true);
-var PackageManifestPayloadSchema = asSchema("network.xyo.manifest.package", true);
-var ModuleManifestPayloadSchema = asSchema("network.xyo.module.manifest", true);
-var NodeManifestPayloadSchema = asSchema("network.xyo.node.manifest", true);
-var NodeManifestPayloadZod = z2.extend(NodeManifestZod, { schema: z2.literal(NodeManifestPayloadSchema) });
-var isNodeManifestPayload = zodIsFactory2(NodeManifestPayloadZod);
-var asNodeManifestPayload = zodAsFactory2(NodeManifestPayloadZod, "asNodeManifestPayload");
-var toNodeManifestPayload = zodToFactory2(NodeManifestPayloadZod, "toNodeManifestPayload");
-var ModuleManifestPayloadZod = z2.extend(ModuleManifestZod, { schema: z2.union([z2.literal(ModuleManifestPayloadSchema), z2.literal(NodeManifestPayloadSchema)]) });
-var isModuleManifestPayload = zodIsFactory2(ModuleManifestPayloadZod);
-var asModuleManifestPayload = zodAsFactory2(ModuleManifestPayloadZod, "asModuleManifestPayload");
-var toModuleManifestPayload = zodToFactory2(ModuleManifestPayloadZod, "toModuleManifestPayload");
-var PackageManifestPayloadZod = z2.extend(PackageManifestZod, { schema: z2.literal(PackageManifestPayloadSchema) });
-var isPackageManifestPayload = zodIsFactory2(PackageManifestPayloadZod);
-var asPackageManifestPayload = zodAsFactory2(PackageManifestPayloadZod, "asPackageManifestPayload");
-var toPackageManifestPayload = zodToFactory2(PackageManifestPayloadZod, "toPackageManifestPayload");
-export {
-  AuthoredDappPackageManifestZod,
-  AuthoredModuleManifestZod,
-  AuthoredNodeManifestZod,
-  AuthoredPackageManifestZod,
-  ConfigManifestZod,
-  DappPackageManifestPayloadSchema,
-  ExternalManifestZod,
-  ExternalModuleRequestZod,
-  ManifestZod,
-  ModuleAliasZod,
-  ModuleAliasZod as ModuleAliasZodSchema,
-  ModuleManifestPayloadSchema,
-  ModuleManifestPayloadZod,
-  ModuleManifestReferenceZod,
-  ModuleManifestStatusZod,
-  ModuleManifestZod,
-  NodeManifestPayloadSchema,
-  NodeManifestPayloadZod,
-  NodeManifestZod,
-  PackageManifestPayloadSchema,
-  PackageManifestPayloadZod,
-  PackageManifestZod,
-  asAuthoredDappPackageManifest,
-  asAuthoredModuleManifest,
-  asAuthoredNodeManifest,
-  asAuthoredPackageManifest,
-  asBrandedZod,
-  asConfigManifest,
-  asManifest,
-  asModuleManifest,
-  asModuleManifestPayload,
-  asNodeManifest,
-  asNodeManifestPayload,
-  asPackageManifest,
-  asPackageManifestPayload,
-  isAuthoredDappPackageManifest,
-  isAuthoredModuleManifest,
-  isAuthoredNodeManifest,
-  isAuthoredPackageManifest,
-  isConfigManifest,
-  isManifest,
-  isModuleManifest,
-  isModuleManifestPayload,
-  isNodeManifest,
-  isNodeManifestPayload,
-  isPackageManifest,
-  isPackageManifestPayload,
-  toAuthoredDappPackageManifest,
-  toAuthoredModuleManifest,
-  toAuthoredNodeManifest,
-  toAuthoredPackageManifest,
-  toConfigManifest,
-  toManifest,
-  toModuleManifest,
-  toModuleManifestPayload,
-  toNodeManifest,
-  toNodeManifestPayload,
-  toPackageManifest,
-  toPackageManifestPayload
-};

package/dist/_pkg/manifest-wrapper/neutral/Wrapper.d.ts

@@ -1,25 +0,0 @@
-import type { Logger } from '@xylabs/sdk';
-import type { ModuleFactoryLocatorInstance, ModuleIdentifierTransformer } from '../../module-model/neutral/index.ts';
-import { MemoryNode } from '../../node-memory/neutral/index.ts';
-import type { ModuleManifest, NodeManifest, PackageManifestPayload, WalletInstance, WithAnySchema } from '../../sdk-protocol/neutral/index.ts';
-import { PayloadWrapper } from '../../sdk-protocol/neutral/index.ts';
-/** Provides functionality that can be performed on a PackageManifest */
-export declare class ManifestWrapper<TManifest extends WithAnySchema<PackageManifestPayload> | void = void> extends PayloadWrapper<TManifest extends WithAnySchema<PackageManifestPayload> ? TManifest : WithAnySchema<PackageManifestPayload>> {
-    protected readonly locator: ModuleFactoryLocatorInstance;
-    protected readonly logger: Logger | undefined;
-    protected readonly moduleIdentifierTransformers: ModuleIdentifierTransformer[] | undefined;
-    protected readonly privateChildren: ModuleManifest[];
-    protected readonly publicChildren: ModuleManifest[];
-    protected readonly wallet: WalletInstance;
-    constructor(payload: TManifest extends WithAnySchema<PackageManifestPayload> ? TManifest : WithAnySchema<PackageManifestPayload>, wallet: WalletInstance, locator: ModuleFactoryLocatorInstance, publicChildren?: ModuleManifest[], privateChildren?: ModuleManifest[], moduleIdentifierTransformers?: ModuleIdentifierTransformer[], logger?: Logger);
-    loadModule(wallet: WalletInstance, node: MemoryNode, manifest: ModuleManifest, external?: boolean): Promise<void>;
-    loadNodeFromIndex(index: number): Promise<MemoryNode>;
-    loadNodeFromManifest(wallet: WalletInstance, manifest: NodeManifest, path?: string, loadConfigChildren?: boolean): Promise<MemoryNode>;
-    /**
-     * Load the nodes that are defined in the wrapped manifest and optionally attach them to a node
-     */
-    loadNodes(node?: MemoryNode): Promise<MemoryNode[]>;
-    nodeManifest(index: number): NodeManifest | undefined;
-    /** Register a module on a node based on a manifest */
-    private registerModule;
-}

package/dist/_pkg/manifest-wrapper/neutral/WrapperEx.d.ts

@@ -1,31 +0,0 @@
-import type { ModuleFactoryLocatorInstance, ModuleIdentifierTransformer } from '../../module-model/neutral/index.ts';
-import { MemoryNode } from '../../node-memory/neutral/index.ts';
-import type { ModuleManifest, NodeManifest, PackageManifestPayload, WalletInstance, WithAnySchema } from '../../sdk-protocol/neutral/index.ts';
-import { PayloadWrapper } from '../../sdk-protocol/neutral/index.ts';
-export interface ManifestWrapperExParams {
-    locator: ModuleFactoryLocatorInstance;
-    moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
-    privateChildren?: ModuleManifest[];
-    publicChildren?: ModuleManifest[];
-    wallet: WalletInstance;
-}
-/** Provides functionality that can be performed on a PackageManifest */
-export declare class ManifestWrapperEx<TManifest extends WithAnySchema<PackageManifestPayload> | void, TParams extends ManifestWrapperExParams = ManifestWrapperExParams> extends PayloadWrapper<TManifest extends WithAnySchema<PackageManifestPayload> ? TManifest : WithAnySchema<PackageManifestPayload>> {
-    protected params: TParams;
-    constructor(payload: TManifest extends WithAnySchema<PackageManifestPayload> ? TManifest : WithAnySchema<PackageManifestPayload>, params: TParams);
-    get locator(): ModuleFactoryLocatorInstance;
-    get moduleIdentifierTransformers(): ModuleIdentifierTransformer[];
-    get privateChildren(): ModuleManifest[];
-    get publicChildren(): ModuleManifest[];
-    get wallet(): WalletInstance;
-    loadModule(wallet: WalletInstance, node: MemoryNode, manifest: ModuleManifest, external?: boolean): Promise<void>;
-    loadNodeFromIndex(index: number): Promise<MemoryNode>;
-    loadNodeFromManifest(wallet: WalletInstance, manifest: NodeManifest, path?: string): Promise<MemoryNode>;
-    /**
-     * Load the nodes that are defined in the wrapped manifest and optionally attach them to a node
-     */
-    loadNodes(node?: MemoryNode): Promise<MemoryNode[]>;
-    nodeManifest(index: number): NodeManifest | undefined;
-    /** Register a module on a node based on a manifest */
-    private registerModule;
-}

package/dist/_pkg/manifest-wrapper/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './Wrapper.ts';
-export * from './WrapperEx.ts';

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

@@ -1,246 +0,0 @@
-// src/Wrapper.ts
-import {
-  assertEx,
-  isDefined,
-  isString
-} from "@xylabs/sdk";
-import { isModuleName } from "../../module-model/neutral/index.mjs";
-import { MemoryNode } from "../../node-memory/neutral/index.mjs";
-import { HDWallet, PayloadWrapper } from "../../sdk-protocol/neutral/index.mjs";
-var ManifestWrapper = class extends PayloadWrapper {
-  locator;
-  logger;
-  moduleIdentifierTransformers;
-  privateChildren;
-  publicChildren;
-  wallet;
-  constructor(payload, wallet, locator, publicChildren = [], privateChildren = [], moduleIdentifierTransformers, logger) {
-    super(payload);
-    this.wallet = wallet;
-    this.locator = locator;
-    this.publicChildren = publicChildren;
-    this.privateChildren = privateChildren;
-    this.moduleIdentifierTransformers = moduleIdentifierTransformers;
-    this.logger = logger;
-  }
-  async loadModule(wallet, node, manifest, external = true) {
-    this.logger?.log("loadModule", manifest.config.name);
-    const collision = async (node2, name, external2) => {
-      const externalConflict = external2 ? await node2.resolve(name, { direction: external2 ? "all" : "down" }) !== void 0 : false;
-      return externalConflict || await node2.resolve(name, { direction: "down" }) !== void 0;
-    };
-    assertEx(isModuleName(manifest.config.name), () => `Invalid Module Name: ${manifest.config.name}`);
-    assertEx(!await collision(node, manifest.config.name, external), () => `Node name collision [${manifest.config.name}]`);
-    if (!await collision(node, manifest.config.name, external)) {
-      if (node.registeredModules().some((mod) => isDefined(mod.config.name) && mod.config.name === manifest.config.name)) {
-        assertEx(await node.attach(manifest.config.name, external), () => `Failed to attach module [${manifest.config.name}]`);
-      } else {
-        if (manifest.modules) {
-          const childNode = await this.loadNodeFromManifest(wallet, manifest, manifest.config.accountPath, false);
-          await node.register(childNode);
-          await node.attach(childNode.address, external);
-        } else {
-          assertEx(
-            await node.attach((await this.registerModule(wallet, node, manifest)).address, external),
-            () => `No module with config schema [${manifest.config.name}] registered`
-          );
-        }
-      }
-    }
-  }
-  // These are top level, so they can use this.wallet as their
-  async loadNodeFromIndex(index) {
-    const manifest = assertEx(this.nodeManifest(index), () => "Failed to find Node Manifest");
-    return await this.loadNodeFromManifest(this.wallet, manifest, manifest.config.accountPath ?? `${index}'`);
-  }
-  async loadNodeFromManifest(wallet, manifest, path, loadConfigChildren = false) {
-    this.logger?.log("loadNodeFromManifest", manifest.config.name);
-    const derivedWallet = isString(path) ? await wallet.derivePath(path) : await HDWallet.random();
-    const node = await MemoryNode.create({
-      account: derivedWallet,
-      config: manifest.config,
-      name: manifest.config.name
-    });
-    const privateModules = manifest.modules?.private?.map(async (moduleManifest) => {
-      if (typeof moduleManifest === "object") {
-        await this.loadModule(derivedWallet, node, moduleManifest, false);
-      }
-    }) ?? [];
-    const publicModules = manifest.modules?.public?.map(async (moduleManifest) => {
-      if (typeof moduleManifest === "object") {
-        await this.loadModule(derivedWallet, node, moduleManifest, true);
-      }
-    }) ?? [];
-    await Promise.all([...privateModules, ...publicModules]);
-    if (loadConfigChildren) {
-      await Promise.all(
-        this.privateChildren.map(async (moduleManifest) => {
-          if (typeof moduleManifest === "object") {
-            await this.loadModule(derivedWallet, node, moduleManifest, false);
-          }
-        })
-      );
-      await Promise.all(
-        this.publicChildren.map(async (moduleManifest) => {
-          if (typeof moduleManifest === "object") {
-            await this.loadModule(derivedWallet, node, moduleManifest, true);
-          }
-        })
-      );
-    }
-    return node;
-  }
-  /**
-   * Load the nodes that are defined in the wrapped manifest and optionally attach them to a node
-   */
-  async loadNodes(node) {
-    return await Promise.all(
-      this.payload.nodes?.map(async (nodeManifest, index) => {
-        const subNode = await this.loadNodeFromManifest(this.wallet, nodeManifest, nodeManifest.config.accountPath ?? `${index}'`, index === 0);
-        await node?.register(subNode);
-        return subNode;
-      })
-    );
-  }
-  nodeManifest(index) {
-    return this.payload.nodes?.[index];
-  }
-  /** Register a module on a node based on a manifest */
-  async registerModule(wallet, node, manifest) {
-    const creatableModule = this.locator.locate(manifest.config.schema, manifest.config.labels);
-    const path = manifest.config.accountPath;
-    const account = isString(path) ? await wallet.derivePath(path) : "random";
-    const params = {
-      name: manifest.config.name,
-      account,
-      config: assertEx(manifest.config, () => "Missing config")
-    };
-    if (this.moduleIdentifierTransformers) {
-      params.moduleIdentifierTransformers = this.moduleIdentifierTransformers;
-    }
-    const mod = await creatableModule.create(params);
-    await node.register(mod);
-    return mod;
-  }
-};
-
-// src/WrapperEx.ts
-import {
-  assertEx as assertEx2,
-  isArray,
-  isString as isString2
-} from "@xylabs/sdk";
-import { isModuleName as isModuleName2 } from "../../module-model/neutral/index.mjs";
-import { MemoryNode as MemoryNode2 } from "../../node-memory/neutral/index.mjs";
-import { HDWallet as HDWallet2, PayloadWrapper as PayloadWrapper2 } from "../../sdk-protocol/neutral/index.mjs";
-var ManifestWrapperEx = class extends PayloadWrapper2 {
-  params;
-  constructor(payload, params) {
-    super(payload);
-    this.params = params;
-  }
-  get locator() {
-    return this.params.locator;
-  }
-  get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? [];
-  }
-  get privateChildren() {
-    return this.params.privateChildren ?? [];
-  }
-  get publicChildren() {
-    return this.params.publicChildren ?? [];
-  }
-  get wallet() {
-    return this.params.wallet;
-  }
-  async loadModule(wallet, node, manifest, external = true) {
-    const collision = async (node2, name, external2) => {
-      const externalConflict = external2 ? await node2.resolve(name, { direction: external2 ? "all" : "down" }) !== void 0 : false;
-      return externalConflict || await node2.resolve(name, { direction: "down" }) !== void 0;
-    };
-    assertEx2(isModuleName2(manifest.config.name), () => `Invalid Module Name: ${manifest.config.name}`);
-    assertEx2(!await collision(node, manifest.config.name, external), () => `Node name collision [${manifest.config.name}]`);
-    if (!await collision(node, manifest.config.name, external)) {
-      if (node.registeredModules().some((mod) => isString2(mod.config.name) && mod.config.name === manifest.config.name)) {
-        assertEx2(await node.attach(manifest.config.name, external), () => `Failed to attach module [${manifest.config.name}]`);
-      } else {
-        assertEx2(
-          await node.attach((await this.registerModule(wallet, node, manifest)).address, external),
-          () => `No module with config schema [${manifest.config.name}] registered`
-        );
-      }
-    }
-  }
-  // These are top level, so they can use this.wallet as their
-  async loadNodeFromIndex(index) {
-    const manifest = assertEx2(this.nodeManifest(index), () => "Failed to find Node Manifest");
-    return await this.loadNodeFromManifest(this.wallet, manifest, manifest.config.accountPath ?? `${index}'`);
-  }
-  async loadNodeFromManifest(wallet, manifest, path) {
-    const derivedWallet = isString2(path) ? await wallet.derivePath(path) : await HDWallet2.random();
-    const node = await MemoryNode2.create({ account: derivedWallet, config: manifest.config });
-    const privateModules = manifest.modules?.private?.map(async (moduleManifest) => {
-      if (typeof moduleManifest === "object") {
-        await this.loadModule(derivedWallet, node, moduleManifest, false);
-      }
-    }) ?? [];
-    const publicModules = manifest.modules?.public?.map(async (moduleManifest) => {
-      if (typeof moduleManifest === "object") {
-        await this.loadModule(derivedWallet, node, moduleManifest, true);
-      }
-    }) ?? [];
-    await Promise.all([...privateModules, ...publicModules]);
-    await Promise.all(
-      this.privateChildren.map(async (moduleManifest) => {
-        if (typeof moduleManifest === "object") {
-          await this.loadModule(derivedWallet, node, moduleManifest, false);
-        }
-      })
-    );
-    await Promise.all(
-      this.publicChildren.map(async (moduleManifest) => {
-        if (typeof moduleManifest === "object") {
-          await this.loadModule(derivedWallet, node, moduleManifest, true);
-        }
-      })
-    );
-    return node;
-  }
-  /**
-   * Load the nodes that are defined in the wrapped manifest and optionally attach them to a node
-   */
-  async loadNodes(node) {
-    return await Promise.all(
-      this.payload.nodes?.map(async (nodeManifest, index) => {
-        const subNode = await this.loadNodeFromManifest(this.wallet, nodeManifest, nodeManifest.config.accountPath ?? `${index}'`);
-        await node?.register(subNode);
-        return subNode;
-      })
-    );
-  }
-  nodeManifest(index) {
-    return this.payload.nodes?.[index];
-  }
-  /** Register a module on a node based on a manifest */
-  async registerModule(wallet, node, manifest) {
-    const creatableModule = this.locator.locate(manifest.config.schema, manifest.config.labels);
-    const path = manifest.config.accountPath;
-    const account = isString2(path) ? await wallet.derivePath(path) : "random";
-    const params = {
-      name: manifest.config.name,
-      account,
-      config: assertEx2(manifest.config, () => "Missing config")
-    };
-    if (isArray(this.moduleIdentifierTransformers)) {
-      params.moduleIdentifierTransformers = this.moduleIdentifierTransformers;
-    }
-    const mod = await creatableModule.create(params);
-    await node.register(mod);
-    return mod;
-  }
-};
-export {
-  ManifestWrapper,
-  ManifestWrapperEx
-};

package/dist/_pkg/metamask-connector/browser/MetaMaskConnector.d.ts

@@ -1,37 +0,0 @@
-import type { MetaMaskInpageProvider } from '@metamask/providers';
-import type { Listener } from 'ethers';
-import { BrowserProvider } from 'ethers';
-declare global {
-    var ethereum: MetaMaskInpageProvider | undefined;
-}
-export declare class MetaMaskConnector {
-    private account;
-    private ethereum;
-    private listeners;
-    private provider;
-    private providerListeners;
-    constructor(provider?: BrowserProvider);
-    get chainId(): string | null | undefined;
-    get currentAccount(): string | null | undefined;
-    connectWallet(): Promise<void>;
-    isMetaMaskInstalled(): true | undefined;
-    isWalletIsConnected(): boolean;
-    /**
-     * EIP-1193 Event Listeners
-     *
-     * .on in Web3Provider does not understand EIP-1193 events
-     * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
-     */
-    providerOnAccountsChanged(listener: Listener): void;
-    providerOnChainChanged(listener: Listener): void;
-    providerOnConnect(listener: Listener): void;
-    providerOnDisconnect(listener: Listener): void;
-    providerRemoveListener(event: string, listener: Listener): void;
-    providerRemoveListeners(): void;
-    requestAccounts(): Promise<string[] | null>;
-    signMessage(message: string): Promise<string | undefined>;
-    /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
-    web3ProviderOn(event: string, listener: Listener): void;
-    web3ProviderRemoveListener(event: string, listener: Listener): void;
-    web3ProviderRemoveListeners(): void;
-}

package/dist/_pkg/metamask-connector/browser/index.d.ts

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

package/dist/_pkg/metamask-connector/browser/index.mjs

@@ -1,113 +0,0 @@
-// src/MetaMaskConnector.ts
-import { forget, isString } from "@xylabs/sdk";
-import { BrowserProvider } from "ethers";
-var MetaMaskConnector = class {
-  account = "";
-  ethereum = globalThis.ethereum;
-  listeners = [];
-  provider;
-  providerListeners = [];
-  constructor(provider) {
-    if (provider) {
-      this.provider = provider;
-    } else if (this.ethereum) {
-      this.provider = new BrowserProvider(this.ethereum);
-    }
-  }
-  get chainId() {
-    return this.ethereum?.networkVersion;
-  }
-  get currentAccount() {
-    return this.ethereum?.selectedAddress;
-  }
-  async connectWallet() {
-    if (!this.provider) {
-      logProviderMissing();
-      return;
-    }
-    const accounts = await this.provider.send("eth_requestAccounts", []);
-    if (accounts.length > 0) {
-      this.account = accounts[0];
-      console.log("Connected:", this.account);
-    } else {
-      console.log("No authorized account found.");
-    }
-  }
-  isMetaMaskInstalled() {
-    return this.ethereum?.isMetaMask;
-  }
-  isWalletIsConnected() {
-    if (isString(this.currentAccount)) {
-      console.log("Found an authorized account:", this.ethereum?.selectedAddress);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * EIP-1193 Event Listeners
-   *
-   * .on in Web3Provider does not understand EIP-1193 events
-   * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
-   */
-  providerOnAccountsChanged(listener) {
-    this.ethereum?.on("accountsChanged", listener);
-    this.providerListeners.push(["accountsChanged", listener]);
-  }
-  providerOnChainChanged(listener) {
-    this.ethereum?.on("chainChanged", listener);
-    this.providerListeners.push(["chainChanged", listener]);
-  }
-  providerOnConnect(listener) {
-    this.ethereum?.on("connect", listener);
-    this.providerListeners.push(["connect", listener]);
-  }
-  providerOnDisconnect(listener) {
-    this.ethereum?.on("disconnect", listener);
-    this.providerListeners.push(["disconnect", listener]);
-  }
-  providerRemoveListener(event, listener) {
-    this.providerListeners = this.providerListeners.filter(([, savedListener]) => listener !== savedListener);
-  }
-  providerRemoveListeners() {
-  }
-  async requestAccounts() {
-    if (!this.provider) {
-      logProviderMissing();
-      return null;
-    }
-    return await this.provider.send("eth_requestAccounts", []);
-  }
-  async signMessage(message) {
-    if (!this.provider) {
-      logProviderMissing();
-      return;
-    }
-    const signer = await this.provider.getSigner();
-    await signer.getAddress();
-    return await signer.signMessage(message);
-  }
-  /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
-  web3ProviderOn(event, listener) {
-    if (this.provider) {
-      forget(this.provider.on(event, listener));
-    }
-    this.listeners.push(listener);
-  }
-  web3ProviderRemoveListener(event, listener) {
-    if (this.provider) {
-      forget(this.provider.removeListener(event, listener));
-    }
-    this.listeners = this.listeners.filter((savedListener) => listener !== savedListener);
-  }
-  web3ProviderRemoveListeners() {
-    if (this.provider) {
-      forget(this.provider.removeAllListeners());
-    }
-  }
-};
-function logProviderMissing() {
-  console.warn("Cannot call this method because there is no web3 provider connected.  Please confirm that metamask is installed");
-}
-export {
-  MetaMaskConnector
-};

package/dist/_pkg/module/neutral/abstract.d.ts

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

package/dist/_pkg/module/neutral/abstract.mjs

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

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

@@ -1,6 +0,0 @@
-export * from '../../module-abstract/neutral/index.ts';
-export * from '../../module-event-emitter/neutral/index.ts';
-export * from '../../module-factory-locator/neutral/index.ts';
-export * from '../../module-model/neutral/index.ts';
-export * from '../../module-resolver/neutral/index.ts';
-export * from '../../module-wrapper/neutral/index.ts';