@xyo-network/module-model 3.6.9 → 3.6.11

package/dist/neutral/index.mjs

@@ -1,6 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/Config/Config.ts
 var ModuleConfigSchema = "network.xyo.module.config";
 
@@ -10,16 +7,14 @@ function creatableModule() {
     constructor;
   };
 }
-__name(creatableModule, "creatableModule");
 function creatableModuleFactory() {
   return (constructor) => {
     constructor;
   };
 }
-__name(creatableModuleFactory, "creatableModuleFactory");
 
 // src/CreatableModule/CreatableModuleRegistry.ts
-var buildModuleFactory = /* @__PURE__ */ __name((mod, labels) => {
+var buildModuleFactory = (mod, labels) => {
   const factory5 = {
     // Destructure instance properties
     ...mod,
@@ -28,23 +23,18 @@ var buildModuleFactory = /* @__PURE__ */ __name((mod, labels) => {
     create: mod.create.bind(mod),
     defaultConfigSchema: mod.defaultConfigSchema,
     // Merge module & supplied labels
-    labels: {
-      ...mod.labels,
-      ...labels
-    }
+    labels: { ...mod.labels, ...labels }
   };
   return factory5;
-}, "buildModuleFactory");
-var registerCreatableModuleFactory = /* @__PURE__ */ __name((registry, factory5, labels, primary = false) => {
-  const primarySchemas = primary !== true && primary ? Array.isArray(primary) ? primary : [
-    primary
-  ] : [];
+};
+var registerCreatableModuleFactory = (registry, factory5, labels, primary = false) => {
+  const primarySchemas = primary !== true && primary ? Array.isArray(primary) ? primary : [primary] : [];
   for (const primarySchema of primarySchemas) {
     if (!factory5.configSchemas.includes(primarySchema)) {
       console.warn(`Primary schema ${primary} not found in factory configSchemas`);
     }
   }
-  const isPrimaryForSchema = /* @__PURE__ */ __name((schema) => {
+  const isPrimaryForSchema = (schema) => {
     switch (typeof primary) {
       case "boolean": {
         return primary;
@@ -59,58 +49,43 @@ var registerCreatableModuleFactory = /* @__PURE__ */ __name((registry, factory5,
       }
     }
     throw new Error(`Invalid primary value: ${primary}`);
-  }, "isPrimaryForSchema");
+  };
   const factoryClone = buildModuleFactory(factory5, labels);
-  registry[factory5.defaultConfigSchema] = [
-    factoryClone,
-    ...registry[factoryClone.defaultConfigSchema] ?? []
-  ];
+  registry[factory5.defaultConfigSchema] = [factoryClone, ...registry[factoryClone.defaultConfigSchema] ?? []];
   for (const schema of factoryClone.configSchemas) {
-    registry[schema] = isPrimaryForSchema(schema) ? [
-      factoryClone,
-      ...registry[schema] ?? []
-    ] : [
-      ...registry[schema] ?? [],
-      factoryClone
-    ];
-  }
-}, "registerCreatableModuleFactory");
-var registerCreatableModuleFactories = /* @__PURE__ */ __name((factories, registry = {}, primary = false) => {
+    registry[schema] = isPrimaryForSchema(schema) ? [factoryClone, ...registry[schema] ?? []] : [...registry[schema] ?? [], factoryClone];
+  }
+};
+var registerCreatableModuleFactories = (factories, registry = {}, primary = false) => {
   for (const factory5 of factories) {
     registerCreatableModuleFactory(registry, factory5, void 0, primary);
   }
   return registry;
-}, "registerCreatableModuleFactories");
-var assignCreatableModuleRegistry = /* @__PURE__ */ __name((target = {}, ...sources) => {
-  for (const source of sources) for (const [schema, factories] of Object.entries(source)) {
-    if (factories) {
-      const existingFactories = target[schema];
-      target[schema] = existingFactories ? target[schema] = [
-        ...existingFactories,
-        ...factories
-      ] : factories;
+};
+var assignCreatableModuleRegistry = (target = {}, ...sources) => {
+  for (const source of sources)
+    for (const [schema, factories] of Object.entries(source)) {
+      if (factories) {
+        const existingFactories = target[schema];
+        target[schema] = existingFactories ? target[schema] = [...existingFactories, ...factories] : factories;
+      }
     }
-  }
   return target;
-}, "assignCreatableModuleRegistry");
+};
 
 // src/CreatableModule/LabeledCreatableModuleFactory.ts
-var hasLabels = /* @__PURE__ */ __name((factory5) => {
+var hasLabels = (factory5) => {
   return factory5.labels !== void 0;
-}, "hasLabels");
+};
 function labeledCreatableModuleFactory() {
   return (constructor) => {
     constructor;
   };
 }
-__name(labeledCreatableModuleFactory, "labeledCreatableModuleFactory");
 
 // src/CreatableModule/ModuleFactory.ts
 import { assertEx } from "@xylabs/assert";
 var ModuleFactory = class _ModuleFactory {
-  static {
-    __name(this, "ModuleFactory");
-  }
   configSchemas;
   creatableModule;
   defaultConfigSchema;
@@ -161,12 +136,9 @@ var ModuleFactory = class _ModuleFactory {
 
 // src/DetailsError.ts
 var ModuleDetailsError = class extends Error {
-  static {
-    __name(this, "ModuleDetailsError");
-  }
-  details;
   constructor(message, details) {
-    super(message), this.details = details;
+    super(message);
+    this.details = details;
     this.name = "ModuleError";
   }
 };
@@ -210,9 +182,6 @@ var asModuleObject = AsObjectFactory.create(isModuleObject);
 
 // src/module/IsModuleFactory.ts
 var IsModuleFactory = class {
-  static {
-    __name(this, "IsModuleFactory");
-  }
   create(expectedQueries, additionalChecks) {
     return (obj, config) => {
       const mod = asModuleObject(obj);
@@ -222,13 +191,9 @@ var IsModuleFactory = class {
 };
 
 // src/module/isModule.ts
-var requiredModuleQueries = [
-  ModuleStateQuerySchema
-];
+var requiredModuleQueries = [ModuleStateQuerySchema];
 var factory2 = new IsModuleFactory();
-var isModule = factory2.create(requiredModuleQueries, [
-  isModuleObject
-]);
+var isModule = factory2.create(requiredModuleQueries, [isModuleObject]);
 
 // src/module/asModule.ts
 var asModule = AsObjectFactory2.create(isModule);
@@ -239,9 +204,7 @@ var requiredModuleInstanceFunctions = {
   state: "function"
 };
 var factory3 = new IsObjectFactory2();
-var isModuleInstance = factory3.create(requiredModuleInstanceFunctions, [
-  isModule
-]);
+var isModuleInstance = factory3.create(requiredModuleInstanceFunctions, [isModule]);
 
 // src/instance/asModuleInstance.ts
 var asModuleInstance = AsObjectFactory3.create(isModuleInstance);
@@ -266,34 +229,25 @@ var asAttachableModuleInstance = AsObjectFactory4.create(isAttachableModuleInsta
 // src/instance/attachable/AttachableInstance.ts
 import { IsObjectFactory as IsObjectFactory4 } from "@xylabs/object";
 var IsAttachableModuleInstanceFactory = class extends IsObjectFactory4 {
-  static {
-    __name(this, "IsAttachableModuleInstanceFactory");
-  }
 };
 
 // src/instance/Instance.ts
 import { IsObjectFactory as IsObjectFactory5, toJsonString } from "@xylabs/object";
 var DeadModuleError = class _DeadModuleError extends Error {
-  static {
-    __name(this, "DeadModuleError");
-  }
-  id;
-  error;
   constructor(id, error, msg = "Dead Module Error") {
-    super(`${msg} [${id}]: ${error?.message ?? toJsonString(error)}`), this.id = id, this.error = error;
+    super(`${msg} [${id}]: ${error?.message ?? toJsonString(error)}`);
+    this.id = id;
+    this.error = error;
     Object.setPrototypeOf(this, _DeadModuleError.prototype);
   }
 };
 var IsInstanceFactory = class extends IsObjectFactory5 {
-  static {
-    __name(this, "IsInstanceFactory");
-  }
 };
 
 // src/instance/ObjectFilter.ts
-var isAddressObjectFilter = /* @__PURE__ */ __name((value) => value.address !== void 0, "isAddressObjectFilter");
-var isNameObjectFilter = /* @__PURE__ */ __name((value) => value.name !== void 0, "isNameObjectFilter");
-var isQueryObjectFilter = /* @__PURE__ */ __name((value) => value.query !== void 0, "isQueryObjectFilter");
+var isAddressObjectFilter = (value) => value.address !== void 0;
+var isNameObjectFilter = (value) => value.name !== void 0;
+var isQueryObjectFilter = (value) => value.query !== void 0;
 
 // src/instance/ModuleFilter.ts
 var isAddressModuleFilter = isAddressObjectFilter;
@@ -301,9 +255,9 @@ var isNameModuleFilter = isNameObjectFilter;
 var isQueryModuleFilter = isQueryObjectFilter;
 
 // src/instance/ObjectResolver.ts
-var isObjectResolver = /* @__PURE__ */ __name((value) => {
+var isObjectResolver = (value) => {
   return typeof value.resolve === "function";
-}, "isObjectResolver");
+};
 var ObjectResolverPriority = {
   Disabled: -1,
   VeryLow: 0,
@@ -317,26 +271,24 @@ var ObjectResolverPriority = {
 var isModuleResolver = isObjectResolver;
 
 // src/Labels/Labels.ts
-var hasAllLabels = /* @__PURE__ */ __name((source, required) => {
+var hasAllLabels = (source, required) => {
   if (!required) return true;
   return Object.entries(required).every(([key, value]) => {
     return source?.hasOwnProperty(key) && source?.[key] === value;
   });
-}, "hasAllLabels");
+};
 
 // src/Labels/standard/View.ts
 var ModuleLimitationLabelName = "network.xyo.module.limitation";
-var ModuleLimitationViewLabel = {
-  ModuleLimitationLabelName: "view"
-};
+var ModuleLimitationViewLabel = { ModuleLimitationLabelName: "view" };
 
 // src/lib/duplicateModules.ts
-var duplicateModules = /* @__PURE__ */ __name((value, index, array) => {
+var duplicateModules = (value, index, array) => {
   return array.findIndex((v) => v.address === value.address) === index;
-}, "duplicateModules");
+};
 
 // src/lib/serializable.ts
-var isSerializable = /* @__PURE__ */ __name((value, maxDepth = 10) => {
+var isSerializable = (value, maxDepth = 10) => {
   if (maxDepth <= 0) {
     return false;
   }
@@ -358,7 +310,7 @@ var isSerializable = /* @__PURE__ */ __name((value, maxDepth = 10) => {
     }
   }
   return false;
-}, "isSerializable");
+};
 
 // src/ModuleIdentifier.ts
 import { isAddress } from "@xylabs/hex";
@@ -394,18 +346,18 @@ var DisallowedModuleIdentifierCharacters = {
   "}": true,
   "~": true
 };
-var ReservedModuleIdentifierCharacters = new Set(Object.keys(DisallowedModuleIdentifierCharacters));
-var isModuleName = /* @__PURE__ */ __name((value) => {
+var ReservedModuleIdentifierCharacters = new Set(
+  Object.keys(DisallowedModuleIdentifierCharacters)
+);
+var isModuleName = (value) => {
   return typeof value === "string" && !isAddress(value) && !includesReservedModuleIdentifierCharacter(value);
-}, "isModuleName");
-var includesReservedModuleIdentifierCharacter = /* @__PURE__ */ __name((value) => {
-  return typeof value === "string" && [
-    ...value
-  ].some((char) => ReservedModuleIdentifierCharacters.has(char));
-}, "includesReservedModuleIdentifierCharacter");
-var isModuleIdentifierPart = /* @__PURE__ */ __name((value) => {
+};
+var includesReservedModuleIdentifierCharacter = (value) => {
+  return typeof value === "string" && [...value].some((char) => ReservedModuleIdentifierCharacters.has(char));
+};
+var isModuleIdentifierPart = (value) => {
   return isModuleName(value) || isAddress(value);
-}, "isModuleIdentifierPart");
+};
 
 // src/Payload/Address.ts
 var AddressSchema = "network.xyo.address";
@@ -421,26 +373,23 @@ var ModuleDescriptionSchema = "network.xyo.module.description";
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/object";
 import { isPayloadOfSchemaType, isPayloadOfSchemaTypeWithSources } from "@xyo-network/payload-model";
 var ModuleStateSchema = "network.xyo.module.state";
-var isModuleState = /* @__PURE__ */ __name((payload) => {
+var isModuleState = (payload) => {
   return isPayloadOfSchemaType(ModuleStateSchema)(payload);
-}, "isModuleState");
-var isModuleStateWithSources = /* @__PURE__ */ __name((payload) => {
+};
+var isModuleStateWithSources = (payload) => {
   return isPayloadOfSchemaTypeWithSources(ModuleStateSchema)(payload);
-}, "isModuleStateWithSources");
+};
 var asModuleState = AsObjectFactory5.create(isModuleState);
 
 // src/ResolveHelper/resolveAddressToInstance.ts
-var resolveAddressToInstanceDown = /* @__PURE__ */ __name(async (root, address, includePrivate = void 0, ignore = []) => {
+var resolveAddressToInstanceDown = async (root, address, includePrivate = void 0, ignore = []) => {
   if (root.address === address) {
     return root;
   }
   const cache = root.addressCache?.("up", !!includePrivate);
   const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
   const publicChildren = await root.publicChildren?.() ?? [];
-  const children = [
-    ...privateChildren,
-    ...publicChildren
-  ];
+  const children = [...privateChildren, ...publicChildren];
   for (const child of children) {
     const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
     if (found) {
@@ -449,8 +398,8 @@ var resolveAddressToInstanceDown = /* @__PURE__ */ __name(async (root, address,
     }
   }
   cache?.set(address, null);
-}, "resolveAddressToInstanceDown");
-var resolveAddressToInstanceSiblings = /* @__PURE__ */ __name(async (root, address, includePrivate = void 0, ignore = []) => {
+};
+var resolveAddressToInstanceSiblings = async (root, address, includePrivate = void 0, ignore = []) => {
   const siblings = await root.siblings?.() ?? [];
   for (const sibling of siblings) {
     const found = await resolveAddressToInstanceDown(sibling, address, includePrivate, ignore);
@@ -458,8 +407,8 @@ var resolveAddressToInstanceSiblings = /* @__PURE__ */ __name(async (root, addre
       return found;
     }
   }
-}, "resolveAddressToInstanceSiblings");
-var resolveAddressToInstanceUp = /* @__PURE__ */ __name(async (root, address, includePrivate = void 0, ignore = []) => {
+};
+var resolveAddressToInstanceUp = async (root, address, includePrivate = void 0, ignore = []) => {
   const cache = root.addressCache?.("up", includePrivate ?? true);
   const parents = await root.parents?.() ?? [];
   for (const parent of parents) {
@@ -470,14 +419,14 @@ var resolveAddressToInstanceUp = /* @__PURE__ */ __name(async (root, address, in
     }
   }
   cache?.set(address, null);
-}, "resolveAddressToInstanceUp");
-var resolveAddressToInstanceAll = /* @__PURE__ */ __name(async (root, address, includePrivate = void 0, ignore = []) => {
+};
+var resolveAddressToInstanceAll = async (root, address, includePrivate = void 0, ignore = []) => {
   const cache = root.addressCache?.("all", !!includePrivate);
   const result = await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore) ?? await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
   cache?.set(address, result ? new WeakRef(result) : null);
   return result;
-}, "resolveAddressToInstanceAll");
-var resolveAddressToInstance = /* @__PURE__ */ __name(async (root, address, includePrivate = void 0, ignore = [], direction = "all") => {
+};
+var resolveAddressToInstance = async (root, address, includePrivate = void 0, ignore = [], direction = "all") => {
   switch (direction) {
     case "all": {
       return await resolveAddressToInstanceAll(root, address, includePrivate, ignore);
@@ -489,67 +438,40 @@ var resolveAddressToInstance = /* @__PURE__ */ __name(async (root, address, incl
       return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore);
     }
   }
-}, "resolveAddressToInstance");
+};
 
 // src/ResolveHelper/resolveAll.ts
-var resolveAllUp = /* @__PURE__ */ __name(async (root, maxDepth = 10, exclude = []) => {
+var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
   if (maxDepth === 0) {
-    return [
-      root
-    ].filter((mod) => !exclude.includes(mod.address));
+    return [root].filter((mod) => !exclude.includes(mod.address));
   }
   const parents = (await root.parents()).filter((mod) => !exclude.includes(mod.address));
   return (maxDepth > 1 ? [
-    ...(await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [
-      ...exclude,
-      root.address
-    ])))).flat(),
-    ...(await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [
-      ...exclude,
-      root.address
-    ], true)))).flat(),
-    ...parents,
-    root
-  ] : [
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)))).flat(),
     ...parents,
     root
-  ]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-}, "resolveAllUp");
-var resolveAllDown = /* @__PURE__ */ __name(async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
+  ] : [...parents, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
   if (maxDepth === 0) {
-    return [
-      root
-    ];
+    return [root];
   }
   const children = (await root.publicChildren()).filter((mod) => !exclude.includes(mod.address));
   const privateChildren = includePrivate ? (await root.privateChildren()).filter((mod) => !exclude.includes(mod.address)) : [];
   return (maxDepth > 1 ? [
     ...children,
-    ...(await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [
-      ...exclude,
-      root.address
-    ])))).flat(),
-    ...(await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [
-      ...exclude,
-      root.address
-    ])))).flat(),
+    ...(await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
     root
-  ] : [
-    ...children,
-    root
-  ]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-}, "resolveAllDown");
-var resolveAll = /* @__PURE__ */ __name(async (root, maxDepth = 10, exclude = []) => {
+  ] : [...children, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAll = async (root, maxDepth = 10, exclude = []) => {
   if (maxDepth === 0) {
-    return [
-      root
-    ];
+    return [root];
   }
-  return [
-    ...await resolveAllUp(root, maxDepth, exclude),
-    ...await resolveAllDown(root, maxDepth, exclude)
-  ].filter(duplicateModules);
-}, "resolveAll");
+  return [...await resolveAllUp(root, maxDepth, exclude), ...await resolveAllDown(root, maxDepth, exclude)].filter(duplicateModules);
+};
 
 // src/ResolveHelper/ResolveHelper.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
@@ -560,9 +482,6 @@ import { toJsonString as toJsonString2 } from "@xylabs/object";
 
 // src/ResolveHelper/ResolveHelperStatic.ts
 var ResolveHelperStatic = class {
-  static {
-    __name(this, "ResolveHelperStatic");
-  }
   static defaultLogger;
   static transformers = [];
 };
@@ -572,23 +491,20 @@ import { assertEx as assertEx2 } from "@xylabs/assert";
 import { asAddress } from "@xylabs/hex";
 
 // src/ResolveHelper/resolveLocalNameToInstance.ts
-var resolveLocalNameToInstanceUp = /* @__PURE__ */ __name(async (root, modName) => {
+var resolveLocalNameToInstanceUp = async (root, modName) => {
   const parents = await root.parents?.() ?? [];
   return parents.find((parent) => parent.config.name === modName);
-}, "resolveLocalNameToInstanceUp");
-var resolveLocalNameToInstanceDown = /* @__PURE__ */ __name(async (root, modName, includePrivate = void 0) => {
+};
+var resolveLocalNameToInstanceDown = async (root, modName, includePrivate = void 0) => {
   const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
   const publicChildren = await root.publicChildren?.() ?? [];
-  const children = [
-    ...privateChildren,
-    ...publicChildren
-  ];
+  const children = [...privateChildren, ...publicChildren];
   return children.find((child) => child.config.name === modName);
-}, "resolveLocalNameToInstanceDown");
-var resolveLocalNameToInstanceAll = /* @__PURE__ */ __name(async (root, modName, includePrivate = false) => {
+};
+var resolveLocalNameToInstanceAll = async (root, modName, includePrivate = false) => {
   return await resolveLocalNameToInstanceDown(root, modName, includePrivate) ?? await resolveLocalNameToInstanceUp(root, modName);
-}, "resolveLocalNameToInstanceAll");
-var resolveLocalNameToInstance = /* @__PURE__ */ __name(async (root, modName, includePrivate = false, direction = "all") => {
+};
+var resolveLocalNameToInstance = async (root, modName, includePrivate = false, direction = "all") => {
   switch (direction) {
     case "all": {
       return await resolveLocalNameToInstanceAll(root, modName, includePrivate);
@@ -600,35 +516,38 @@ var resolveLocalNameToInstance = /* @__PURE__ */ __name(async (root, modName, in
       return await resolveLocalNameToInstanceDown(root, modName, includePrivate);
     }
   }
-}, "resolveLocalNameToInstance");
+};
 
 // src/ResolveHelper/resolveLocalNameToAddress.ts
-var resolveLocalNameToAddressUp = /* @__PURE__ */ __name(async (root, modName) => {
+var resolveLocalNameToAddressUp = async (root, modName) => {
   return (await resolveLocalNameToInstanceUp(root, modName))?.address;
-}, "resolveLocalNameToAddressUp");
-var resolveLocalNameToAddressDown = /* @__PURE__ */ __name(async (root, modName, includePrivate = void 0) => {
+};
+var resolveLocalNameToAddressDown = async (root, modName, includePrivate = void 0) => {
   return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address;
-}, "resolveLocalNameToAddressDown");
-var resolveLocalNameToAddressAll = /* @__PURE__ */ __name(async (root, modName, includePrivate = void 0) => {
+};
+var resolveLocalNameToAddressAll = async (root, modName, includePrivate = void 0) => {
   return (await resolveLocalNameToInstanceAll(root, modName, includePrivate))?.address;
-}, "resolveLocalNameToAddressAll");
-var resolveLocalNameToAddress = /* @__PURE__ */ __name(async (root, modName, includePrivate = void 0, direction = "all") => {
+};
+var resolveLocalNameToAddress = async (root, modName, includePrivate = void 0, direction = "all") => {
   return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
-}, "resolveLocalNameToAddress");
+};
 
 // src/ResolveHelper/transformModuleIdentifier.ts
-var transformModuleIdentifier = /* @__PURE__ */ __name(async (id, transformers) => {
+var transformModuleIdentifier = async (id, transformers) => {
   let result = id;
   for (const transformer of transformers) {
     result = await transformer.transform(id);
   }
   return result;
-}, "transformModuleIdentifier");
+};
 
 // src/ResolveHelper/resolvePathToInstance.ts
-var resolvePathToInstance = /* @__PURE__ */ __name(async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+var resolvePathToInstance = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
   const parts = path.split(MODULE_PATH_SEPARATOR);
-  const first = await transformModuleIdentifier(assertEx2(parts.shift(), () => `First part is invalid [${path}]`), transformers);
+  const first = await transformModuleIdentifier(
+    assertEx2(parts.shift(), () => `First part is invalid [${path}]`),
+    transformers
+  );
   if (!first) {
     return void 0;
   }
@@ -640,39 +559,44 @@ var resolvePathToInstance = /* @__PURE__ */ __name(async (root, path, includePri
     }
     return firstModule;
   }
-}, "resolvePathToInstance");
+};
 
 // src/ResolveHelper/resolvePathToAddress.ts
-var resolvePathToAddress = /* @__PURE__ */ __name(async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+var resolvePathToAddress = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
   return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
-}, "resolvePathToAddress");
+};
 
 // src/ResolveHelper/traceModuleIdentifier.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
-var traceModuleIdentifier = /* @__PURE__ */ __name(async (resolver, path) => {
+var traceModuleIdentifier = async (resolver, path) => {
   const parts = path.split(":");
   const first = parts.shift();
-  const firstModule = asModuleInstance(assertEx3(await resolver.resolve(first, {
-    maxDepth: 1
-  }), () => `Failed to resolve [${first}]`), () => `Resolved invalid module instance [${first}]`);
+  const firstModule = asModuleInstance(
+    assertEx3(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
+    () => `Resolved invalid module instance [${first}]`
+  );
   if (firstModule) {
-    return parts.length > 0 ? [
-      firstModule.address,
-      ...await traceModuleIdentifier(firstModule, parts.join(":"))
-    ] : [
-      firstModule.address
-    ];
+    return parts.length > 0 ? [firstModule.address, ...await traceModuleIdentifier(firstModule, parts.join(":"))] : [firstModule.address];
   }
   return [];
-}, "traceModuleIdentifier");
+};
 
 // src/ResolveHelper/ResolveHelper.ts
 var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
-  static {
-    __name(this, "ResolveHelper");
-  }
-  static async resolve(config, idOrFilter = "*", { maxDepth = 3, required = "log", ...options } = {}) {
-    const { transformers, mod, logger = this.defaultLogger, dead = false, upResolver, downResolver, privateResolver } = config;
+  static async resolve(config, idOrFilter = "*", {
+    maxDepth = 3,
+    required = "log",
+    ...options
+  } = {}) {
+    const {
+      transformers,
+      mod,
+      logger = this.defaultLogger,
+      dead = false,
+      upResolver,
+      downResolver,
+      privateResolver
+    } = config;
     const log = logger ? new IdLogger(logger, () => `ResolveHelper [${mod.id}][${idOrFilter}]`) : void 0;
     const downLocalOptions = {
       ...options,
@@ -680,10 +604,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
       maxDepth,
       required: false
     };
-    const upLocalOptions = {
-      ...downLocalOptions,
-      direction: "up"
-    };
+    const upLocalOptions = { ...downLocalOptions, direction: "up" };
     const childOptions = {
       ...options,
       maxDepth: maxDepth - 1,
@@ -711,11 +632,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
         return modules;
       }
       const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules);
-      return [
-        ...modules,
-        ...childModules,
-        mod
-      ].filter(duplicateModules);
+      return [...modules, ...childModules, mod].filter(duplicateModules);
     } else {
       switch (typeof idOrFilter) {
         case "string": {
@@ -725,18 +642,9 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
           const id = await resolvePathToAddress(mod, idOrFilter, false, transformers) ?? idOrFilter;
           if (id) {
             const resolvers = [
-              [
-                downResolver,
-                downLocalOptions
-              ],
-              [
-                up ? upResolver : void 0,
-                upLocalOptions
-              ],
-              [
-                up ? privateResolver : void 0,
-                upLocalOptions
-              ]
+              [downResolver, downLocalOptions],
+              [up ? upResolver : void 0, upLocalOptions],
+              [up ? privateResolver : void 0, upLocalOptions]
             ].filter(([resolver]) => exists(resolver));
             for (const resolver of resolvers) {
               const [resolverInstance] = resolver;
@@ -768,11 +676,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
     const parts = path.split(":");
     const first = parts.shift();
     const firstIsAddress = isAddress2(first);
-    const resolvedModule = await resolver.resolve(first, {
-      maxDepth: firstIsAddress ? 10 : 1
-    }) ?? (first ? await resolver.resolvePrivate(first, {
-      maxDepth: firstIsAddress ? 10 : 1
-    }) : void 0);
+    const resolvedModule = await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }) ?? (first ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : void 0);
     const finalModule = required ? assertEx4(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
     const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`);
     if (firstModule) {
@@ -808,11 +712,11 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
 
 // src/withModule.ts
 var WithFactory = {
-  create: /* @__PURE__ */ __name((typeCheck) => {
+  create: (typeCheck) => {
     return (mod, closure) => {
       return typeCheck(mod) ? closure(mod) : void 0;
     };
-  }, "create")
+  }
 };
 var withModule = WithFactory.create(isModule);
 var withModuleInstance = WithFactory.create(isModuleInstance);