@xyo-network/sdk 7.0.3 → 7.0.4

package/dist/_pkg/module-resolver/neutral/index.mjs

@@ -1,766 +0,0 @@
-// src/AbstractModuleResolver.ts
-import {
-  assertEx,
-  Base,
-  toSafeJsonString
-} from "@xylabs/sdk";
-import {
-  asModuleInstance,
-  ObjectResolverPriority
-} from "../../module-model/neutral/index.mjs";
-var AbstractModuleResolver = class extends Base {
-  get priority() {
-    return this.params.priority ?? ObjectResolverPriority.Normal;
-  }
-  set priority(value) {
-    this.params.priority = value;
-  }
-  get root() {
-    return assertEx(this.params.root, () => "root is not set");
-  }
-  async resolve(id = "*", options) {
-    if (id === "*") {
-      const values = await this.resolveHandler(id, options);
-      assertEx(Array.isArray(values), () => "resolveHandler returned a non-array");
-      return values.map((value) => asModuleInstance(value, () => {
-        return `resolveHandler returned invalid result (*) [${value?.constructor?.name}][${toSafeJsonString(value)}]`;
-      }, { required: true }));
-    }
-    switch (typeof id) {
-      case "string": {
-        const [value] = await this.resolveHandler(id, options);
-        return asModuleInstance(
-          value,
-          () => (
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-            `resolveHandler returned invalid result (string) [${value?.constructor?.name}][${toSafeJsonString(value)}]`
-          )
-        );
-      }
-      default: {
-        break;
-      }
-    }
-  }
-  async resolvePrivate(id, _options) {
-    if (id === "*") return await Promise.resolve([]);
-  }
-};
-
-// src/CompositeModuleResolver.ts
-import {
-  assertEx as assertEx6,
-  exists as exists3,
-  isDefined as isDefined2,
-  isString as isString2
-} from "@xylabs/sdk";
-import {
-  duplicateModules as duplicateModules3,
-  ObjectResolverPriority as ObjectResolverPriority2
-} from "../../module-model/neutral/index.mjs";
-import { LRUCache } from "lru-cache";
-
-// src/ResolveHelper/resolveAddressToInstance.ts
-var resolveAddressToInstanceDown = async (root, address, includePrivate, 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];
-  for (const child of children) {
-    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
-    if (found) {
-      cache?.set(address, new WeakRef(found));
-      return found;
-    }
-  }
-  cache?.set(address, null);
-};
-var resolveAddressToInstanceSiblings = async (root, address, includePrivate, ignore = []) => {
-  const siblings = await root.siblings?.() ?? [];
-  for (const sibling of siblings) {
-    const found = await resolveAddressToInstanceDown(sibling, address, includePrivate, ignore);
-    if (found) {
-      return found;
-    }
-  }
-};
-var resolveAddressToInstanceUp = async (root, address, includePrivate, ignore = []) => {
-  const cache = root.addressCache?.("up", includePrivate ?? true);
-  const parents = await root.parents?.() ?? [];
-  for (const parent of parents) {
-    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore);
-    if (found) {
-      cache?.set(address, new WeakRef(found));
-      return found;
-    }
-  }
-  cache?.set(address, null);
-};
-var resolveAddressToInstanceAll = async (root, address, includePrivate, 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;
-};
-var resolveAddressToInstance = async (root, address, includePrivate, ignore = [], direction = "all") => {
-  switch (direction) {
-    case "all": {
-      return await resolveAddressToInstanceAll(root, address, includePrivate, ignore);
-    }
-    case "up": {
-      return await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
-    }
-    case "down": {
-      return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore);
-    }
-  }
-};
-
-// src/ResolveHelper/resolveAll.ts
-import { duplicateModules } from "../../module-model/neutral/index.mjs";
-var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
-  if (maxDepth === 0) {
-    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
-  ] : [...parents, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-};
-var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
-  if (maxDepth === 0) {
-    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(),
-    root
-  ] : [...children, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-};
-var resolveAll = async (root, maxDepth = 10, exclude = []) => {
-  if (maxDepth === 0) {
-    return [root];
-  }
-  return [...await resolveAllUp(root, maxDepth, exclude), ...await resolveAllDown(root, maxDepth, exclude)].filter(duplicateModules);
-};
-
-// src/ResolveHelper/ResolveHelper.ts
-import {
-  assertEx as assertEx4,
-  exists,
-  IdLogger,
-  isAddress,
-  isDefined,
-  isString,
-  isTruthy
-} from "@xylabs/sdk";
-import { asModuleInstance as asModuleInstance3, duplicateModules as duplicateModules2 } from "../../module-model/neutral/index.mjs";
-
-// src/ResolveHelper/ResolveHelperStatic.ts
-var ResolveHelperStatic = class {
-  static defaultLogger;
-  static transformers = [];
-};
-
-// src/ResolveHelper/resolvePathToInstance.ts
-import { asAddress, assertEx as assertEx2 } from "@xylabs/sdk";
-import { MODULE_PATH_SEPARATOR } from "../../module-model/neutral/index.mjs";
-
-// src/ResolveHelper/resolveLocalNameToInstance.ts
-var resolveLocalNameToInstanceUp = async (root, modName) => {
-  const parents = await root.parents?.() ?? [];
-  return parents.find((parent) => parent.config.name === modName);
-};
-var resolveLocalNameToInstanceDown = async (root, modName, includePrivate) => {
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
-  const publicChildren = await root.publicChildren?.() ?? [];
-  const children = [...privateChildren, ...publicChildren];
-  return children.find((child) => child.config.name === modName);
-};
-var resolveLocalNameToInstanceAll = async (root, modName, includePrivate = false) => {
-  return await resolveLocalNameToInstanceDown(root, modName, includePrivate) ?? await resolveLocalNameToInstanceUp(root, modName);
-};
-var resolveLocalNameToInstance = async (root, modName, includePrivate = false, direction = "all") => {
-  switch (direction) {
-    case "all": {
-      return await resolveLocalNameToInstanceAll(root, modName, includePrivate);
-    }
-    case "up": {
-      return await resolveLocalNameToInstanceUp(root, modName);
-    }
-    case "down": {
-      return await resolveLocalNameToInstanceDown(root, modName, includePrivate);
-    }
-  }
-};
-
-// src/ResolveHelper/resolveLocalNameToAddress.ts
-var resolveLocalNameToAddressUp = async (root, modName) => {
-  return (await resolveLocalNameToInstanceUp(root, modName))?.address;
-};
-var resolveLocalNameToAddressDown = async (root, modName, includePrivate) => {
-  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address;
-};
-var resolveLocalNameToAddressAll = async (root, modName, includePrivate) => {
-  return (await resolveLocalNameToInstanceAll(root, modName, includePrivate))?.address;
-};
-var resolveLocalNameToAddress = async (root, modName, includePrivate, direction = "all") => {
-  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
-};
-
-// src/ResolveHelper/transformModuleIdentifier.ts
-var transformModuleIdentifier = async (id, transformers) => {
-  let result = id;
-  for (const transformer of transformers) {
-    result = await transformer.transform(id);
-  }
-  return result;
-};
-
-// src/ResolveHelper/resolvePathToInstance.ts
-var resolvePathToInstance = async (root, path, includePrivate, transformers = ResolveHelperStatic.transformers) => {
-  const parts = path.split(MODULE_PATH_SEPARATOR);
-  const first = await transformModuleIdentifier(
-    assertEx2(parts.shift(), () => `First part is invalid [${path}]`),
-    transformers
-  );
-  if (!first) {
-    return void 0;
-  }
-  const firstAddress = asAddress(first) ?? await resolveLocalNameToAddress(root, first, includePrivate);
-  if (firstAddress) {
-    const firstModule = await resolveAddressToInstance(root, firstAddress, includePrivate);
-    if (firstModule && parts.length > 0) {
-      return resolvePathToInstance(firstModule, parts.join(MODULE_PATH_SEPARATOR));
-    }
-    return firstModule;
-  }
-};
-
-// src/ResolveHelper/resolvePathToAddress.ts
-var resolvePathToAddress = async (root, path, includePrivate, transformers = ResolveHelperStatic.transformers) => {
-  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
-};
-
-// src/ResolveHelper/traceModuleIdentifier.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk";
-import { asModuleInstance as asModuleInstance2 } from "../../module-model/neutral/index.mjs";
-var traceModuleIdentifier = async (resolver, path) => {
-  const parts = path.split(":");
-  const first = parts.shift();
-  const firstModule = asModuleInstance2(
-    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 [];
-};
-
-// src/ResolveHelper/ResolveHelper.ts
-var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
-  static async resolve(config, id = "*", {
-    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}][${id}]`) : void 0;
-    const downLocalOptions = {
-      ...options,
-      direction: "down",
-      maxDepth,
-      required: false
-    };
-    const upLocalOptions = { ...downLocalOptions, direction: "up" };
-    const childOptions = {
-      ...options,
-      maxDepth: maxDepth - 1,
-      required: false
-    };
-    const direction = options?.direction ?? "all";
-    const up = direction === "up" || direction === "all";
-    const down = direction === "down" || direction === "all";
-    let result;
-    log?.debug("start", id, maxDepth);
-    if (id === "*") {
-      if (dead) {
-        log?.warn("failed [dead]", id);
-        return [];
-      }
-      const modules = [
-        ...down ? await downResolver.resolve("*", downLocalOptions) : [],
-        ...up ? await upResolver.resolve("*", upLocalOptions) : []
-      ].filter(duplicateModules2);
-      if (modules.length > 0) {
-        log?.debug("modules [count]", modules.length);
-      }
-      if (maxDepth === 0) {
-        return modules;
-      }
-      const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules2);
-      return [...modules, ...childModules, mod].filter(duplicateModules2);
-    } else {
-      switch (typeof id) {
-        case "string": {
-          if (dead) {
-            return void 0;
-          }
-          const resolvedId = assertEx4(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
-          const resolvers = [
-            [downResolver, downLocalOptions],
-            [up ? upResolver : void 0, upLocalOptions],
-            [up ? privateResolver : void 0, upLocalOptions]
-          ].filter(([resolver]) => exists(resolver));
-          for (const resolver of resolvers) {
-            const [resolverInstance] = resolver;
-            result ??= await this.resolveModuleIdentifier(resolverInstance, resolvedId);
-          }
-          break;
-        }
-        default: {
-          break;
-        }
-      }
-    }
-    this.validateRequiredResolve(required, result, id, logger);
-    return result;
-  }
-  // resolves a complex module path to addresses
-  static async resolveModuleIdentifier(resolver, path, required) {
-    const parts = path.split(":");
-    const first = parts.shift();
-    const firstIsAddress = isAddress(first);
-    const resolvedModule = await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }) ?? (isString(first) ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : void 0);
-    const finalModule = required ? assertEx4(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
-    const firstModule = asModuleInstance3(finalModule, () => `Resolved invalid module instance [${first}]`);
-    return isDefined(firstModule) ? parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule : void 0;
-  }
-  // translates a complex module path to addresses
-  static traceModuleIdentifier(resolver, path) {
-    return traceModuleIdentifier(resolver, path);
-  }
-  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
-    return transformModuleIdentifier(identifier, transformers);
-  }
-  static validateRequiredResolve(required, result, id, logger = this.defaultLogger) {
-    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${id}][${JSON.stringify(result)}]`) : void 0;
-    if (isTruthy(required) && (result === void 0 || Array.isArray(result) && result.length > 0)) {
-      switch (required) {
-        case "warn": {
-          log?.warn("resolve failed", id);
-          break;
-        }
-        case "log": {
-          log?.log("resolve failed", id);
-          break;
-        }
-        default: {
-          throw new Error(`resolve failed [${id}]`);
-        }
-      }
-    }
-  }
-};
-
-// src/SimpleModuleResolver.ts
-import {
-  assertEx as assertEx5,
-  exists as exists2,
-  isAddress as isAddress2
-} from "@xylabs/sdk";
-import { isModuleName } from "../../module-model/neutral/index.mjs";
-var SimpleModuleResolver = class extends AbstractModuleResolver {
-  modules = {};
-  nameToModule = {};
-  constructor(params) {
-    super(params);
-  }
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true;
-  }
-  add(mods) {
-    if (Array.isArray(mods)) {
-      for (const mod of mods) this.addSingleModule(mod);
-    } else {
-      this.addSingleModule(mods);
-    }
-    return this;
-  }
-  addResolver(_resolver) {
-    throw new Error("Adding resolvers not supported");
-  }
-  remove(address) {
-    if (Array.isArray(address)) {
-      for (const addr of address) this.removeSingleModule(addr);
-    } else {
-      this.removeSingleModule(address);
-    }
-    return this;
-  }
-  removeResolver(_resolver) {
-    throw new Error("Removing resolvers not supported");
-  }
-  resolveHandler(id = "*", options) {
-    const unfiltered = (() => {
-      if (id) {
-        if (typeof id === "string") {
-          if (id === "*") {
-            return Object.values(this.modules);
-          }
-          const name = isModuleName(id) ? id : void 0;
-          const address = isAddress2(id) ? id : void 0;
-          assertEx5(name ?? address, () => "module identifier must be a ModuleName or Address");
-          return (name ? this.resolveByName(Object.values(this.modules), [name]).pop() : void 0) ?? (address ? this.resolveByAddress(this.modules, [address]).pop() : void 0);
-        }
-      } else {
-        return Object.values(this.modules);
-      }
-    })();
-    const identity = options?.identity;
-    if (identity) {
-      return Array.isArray(unfiltered) ? unfiltered?.filter((mod) => identity(mod)) : identity(unfiltered) ? [unfiltered] : [];
-    } else {
-      return unfiltered ? Array.isArray(unfiltered) ? unfiltered : [unfiltered] : [];
-    }
-  }
-  resolveIdentifier(id, _options) {
-    const moduleFromName = this.nameToModule[id];
-    if (moduleFromName) {
-      return moduleFromName.address;
-    }
-    for (const mod of Object.values(this.modules)) {
-      if (mod.address === id) {
-        return mod.address;
-      }
-    }
-  }
-  addSingleModule(mod) {
-    if (mod) {
-      const modName = mod.modName;
-      if (modName && this.allowNameResolution) {
-        assertEx5(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
-        this.nameToModule[modName] = mod;
-      }
-      this.modules[mod.address] = mod;
-    }
-  }
-  removeSingleModule(address) {
-    assertEx5(isAddress2(address), () => "Invalid address");
-    const mod = assertEx5(this.modules[address], () => "Address not found in modules");
-    delete this.modules[address];
-    const modName = mod.modName;
-    if (modName) {
-      delete this.nameToModule[modName];
-    }
-  }
-  resolveByAddress(modules, address) {
-    return address.map((address2) => {
-      return modules[address2];
-    }).filter(exists2);
-  }
-  resolveByName(modules, name) {
-    return name.map((name2) => {
-      return modules.find((mod) => mod.modName === name2);
-    }).filter(exists2);
-  }
-  resolveByQuery(modules, query) {
-    return modules.filter((mod) => query?.reduce((supported, queryList) => {
-      return queryList.reduce((supported2, query2) => {
-        const queryable = mod.queries.includes(query2);
-        return supported2 && queryable;
-      }, true) || supported;
-    }, false)).filter(exists2);
-  }
-};
-
-// src/CompositeModuleResolver.ts
-var moduleIdentifierParts = (moduleIdentifier) => {
-  return moduleIdentifier?.split(":");
-};
-var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractModuleResolver {
-  static defaultMaxDepth = 3;
-  _cache;
-  resolvers = [];
-  _allowAddResolver = true;
-  _localResolver;
-  constructor(params) {
-    super(params);
-    const localResolver = new SimpleModuleResolver({ allowNameResolution: params.allowNameResolution, root: params.root });
-    this.addResolver(localResolver);
-    const {
-      max = 100,
-      ttl = 1e3 * 5
-      /* five seconds */
-    } = params.cache ?? {};
-    this._cache = new LRUCache({
-      max,
-      ttl,
-      ...params.cache
-    });
-    this._localResolver = localResolver;
-  }
-  get allowAddResolver() {
-    return this._allowAddResolver;
-  }
-  set allowAddResolver(value) {
-    this.resolvers = [this._localResolver];
-    this._allowAddResolver = value;
-  }
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true;
-  }
-  get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers;
-  }
-  add(mod) {
-    if (Array.isArray(mod)) {
-      for (const modItem of mod) this.addSingleModule(modItem);
-    } else {
-      this.addSingleModule(mod);
-    }
-    return this;
-  }
-  addResolver(resolver) {
-    if (this.allowAddResolver) {
-      this.resolvers.push(resolver);
-    }
-    return this;
-  }
-  remove(addresses) {
-    if (Array.isArray(addresses)) {
-      for (const address of addresses) this.removeSingleModule(address);
-    } else {
-      this.removeSingleModule(addresses);
-    }
-    return this;
-  }
-  removeResolver(resolver) {
-    this.resolvers = this.resolvers.filter((item) => item !== resolver);
-    return this;
-  }
-  // eslint-disable-next-line complexity
-  async resolveHandler(id = "*", options = {}) {
-    const mutatedOptions = { ...options, maxDepth: options?.maxDepth ?? _CompositeModuleResolver.defaultMaxDepth };
-    if (id === "*") {
-      if (mutatedOptions.maxDepth < 0) {
-        return [];
-      }
-      if (mutatedOptions.maxDepth === 0) {
-        return await this._localResolver.resolve("*", mutatedOptions) ?? [];
-      }
-      const childOptions = { ...mutatedOptions, maxDepth: mutatedOptions?.maxDepth - 1 };
-      const result = await Promise.all(
-        this.resolvers.map(async (resolver) => {
-          const result2 = await resolver.resolve("*", childOptions);
-          return result2;
-        })
-      );
-      const flatResult = result.flat().filter(exists3);
-      return flatResult.filter((v, i, a) => duplicateModules3(v, i, a));
-    }
-    if (typeof id === "string") {
-      if (mutatedOptions.maxDepth < 0) {
-        return [];
-      }
-      const idParts = moduleIdentifierParts(id);
-      if (idParts.length > 1) {
-        const mod = await this.resolveMultipartIdentifier(id);
-        return mod ? Array.isArray(mod) ? mod : [mod] : [];
-      }
-      const resolvedId = await ResolveHelper.transformModuleIdentifier(id, this.moduleIdentifierTransformers);
-      if (isString2(resolvedId)) {
-        if (mutatedOptions.maxDepth < 0) {
-          return [];
-        }
-        const cachedResult = this._cache.get(resolvedId);
-        if (cachedResult) {
-          if (cachedResult.status === "error") {
-            this._cache.delete(id);
-          } else {
-            return [cachedResult];
-          }
-        }
-        if (mutatedOptions.maxDepth === 0) {
-          const mod2 = await this._localResolver.resolve(resolvedId, mutatedOptions);
-          return isDefined2(mod2) ? Array.isArray(mod2) ? mod2 : [mod2] : [];
-        }
-        const resolvePriority = async (priority) => {
-          const resolvers = this.resolvers.filter((resolver) => resolver.priority === priority);
-          const results = (await Promise.all(
-            resolvers.map(async (resolver) => {
-              const result2 = await resolver.resolve(resolvedId, mutatedOptions);
-              return result2;
-            })
-          )).filter(exists3);
-          const result = results.filter(exists3).findLast((v, i, a) => duplicateModules3(v, i, a));
-          if (result) {
-            this._cache.set(resolvedId, result);
-            return result;
-          }
-          return priority === ObjectResolverPriority2.VeryLow ? void 0 : await resolvePriority(priority - 1);
-        };
-        const mod = await resolvePriority(ObjectResolverPriority2.VeryHigh);
-        return mod ? Array.isArray(mod) ? mod : [mod] : [];
-      }
-    }
-    return [];
-  }
-  async resolveIdentifier(id, _options) {
-    const idParts = id.split(":");
-    if (idParts.length > 1) {
-      return this.resolveComplexIdentifier(id);
-    }
-    const results = (await Promise.all(
-      this.resolvers.map(async (resolver) => {
-        return await resolver.resolveIdentifier(id);
-      })
-    )).filter(exists3);
-    const result = results.shift();
-    if (results.length > 0) {
-      for (const altResult of results) {
-        assertEx6(altResult === result, () => `Inconsistent results for ${id} [${result}][${altResult}]`);
-      }
-    }
-    return result;
-  }
-  resolveComplexIdentifier(_id, _options) {
-    throw new Error("Method not implemented.");
-  }
-  addSingleModule(mod) {
-    if (mod) {
-      this._localResolver.add(mod);
-    }
-  }
-  removeSingleModule(address) {
-    this._localResolver.remove(address);
-  }
-  async resolveMultipartIdentifier(moduleIdentifier) {
-    const idParts = moduleIdentifierParts(moduleIdentifier);
-    assertEx6(idParts.length >= 2, () => "Not a valid multipart identifier");
-    const id = assertEx6(idParts.shift());
-    const mod = await this.resolve(id) ?? await this.resolvePrivate(id);
-    return await mod?.resolve(idParts.join(":")) ?? await mod?.resolvePrivate(idParts.join(":"));
-  }
-};
-
-// src/NameRegistrarTransformer.ts
-import { isDefined as isDefined3, isUndefined } from "@xylabs/sdk";
-import { PayloadDivinerQuerySchema } from "../../diviner-payload-model/neutral/index.mjs";
-import { LRUCache as LRUCache2 } from "lru-cache";
-var NameRegistrarTransformer = class {
-  _cache = new LRUCache2({ max: 1e3, ttl: 1e3 * 5 });
-  registrarDiviner;
-  root;
-  constructor(registrarDiviner, root) {
-    this.registrarDiviner = registrarDiviner;
-    this.root = root;
-  }
-  async transform(identifier) {
-    const parts = identifier.split(":");
-    const first = parts.shift();
-    const nameParts = first?.split(".");
-    if (nameParts?.length === 2 && nameParts[1] === this.root) {
-      const cachedResult = this._cache.get(identifier);
-      if (isDefined3(cachedResult)) return cachedResult;
-      const query = {
-        domain: nameParts[0],
-        order: "desc",
-        schema: PayloadDivinerQuerySchema,
-        tld: nameParts[1]
-      };
-      const result = await this.registrarDiviner?.divine([query]);
-      const resultPayload = result?.shift();
-      if (isUndefined(resultPayload)) {
-        throw new Error(`Unable to resolve registrar name (failed) [${first}]`);
-      }
-      if (isDefined3(resultPayload)) {
-        const address = resultPayload.address?.shift();
-        if (address) {
-          this._cache.set(identifier, address);
-          return address;
-        }
-      }
-      throw new Error(`Unable to resolve registrar name (not found) [${first}]`);
-    }
-    return identifier;
-  }
-};
-
-// src/ResolverEventEmitter.ts
-var getMixin = (resolver) => {
-  const listeners = [];
-  const emit = (event, args) => {
-    if (listeners.length === 0) return false;
-    for (const listener of listeners) listener(args);
-    return true;
-  };
-  const onModuleResolved = (mod, id) => {
-    const args = { id, mod };
-    emit("moduleResolved", args);
-  };
-  const { resolve } = resolver;
-  function originalResolve(filter) {
-    return resolve.bind(resolver)(filter);
-  }
-  return {
-    on: (event, listener) => {
-      listeners.push(listener);
-    },
-    resolve: async (id) => {
-      const modulesResult = await originalResolve(id) ?? [];
-      const modules = Array.isArray(modulesResult) ? modulesResult : [modulesResult];
-      await Promise.allSettled(modules.map((mod) => onModuleResolved(mod, id)));
-      return modules;
-    }
-  };
-};
-var mixinResolverEventEmitter = (resolver) => {
-  const mixin = getMixin(resolver);
-  return Object.assign(resolver, mixin);
-};
-export {
-  AbstractModuleResolver,
-  CompositeModuleResolver,
-  NameRegistrarTransformer,
-  ResolveHelper,
-  SimpleModuleResolver,
-  mixinResolverEventEmitter,
-  resolveAddressToInstance,
-  resolveAddressToInstanceAll,
-  resolveAddressToInstanceDown,
-  resolveAddressToInstanceSiblings,
-  resolveAddressToInstanceUp,
-  resolveAll,
-  resolveAllDown,
-  resolveAllUp,
-  resolveLocalNameToAddress,
-  resolveLocalNameToAddressAll,
-  resolveLocalNameToAddressDown,
-  resolveLocalNameToAddressUp,
-  resolveLocalNameToInstance,
-  resolveLocalNameToInstanceAll,
-  resolveLocalNameToInstanceDown,
-  resolveLocalNameToInstanceUp,
-  resolvePathToAddress,
-  resolvePathToInstance,
-  transformModuleIdentifier
-};