* Threads from our private pool are never interrupted. Threads from a
                 * user-supplied executor might be, but... what can we do? This is another reason
                 * to return a proper ListenableFuture instead of using listenInPoolThread.
                 */
                getUninterruptibly(delegate);
              } catch (Throwable t) {

 * @see eu.maveniverse.domtrip.maven.PomEditor
 */
public class DomUtils {

    private DomUtils() {
        // Utility class
    }

    /**
     * Inserts a new child element to the given parent element with proper Maven POM ordering.
     *
     * @param name the name of the new element
     * @param parent the parent element
     * @return the new element
     *
     */

    Executor renamingExecutor =
        renamingDecorator(newDirectExecutorService(), Suppliers.ofInstance("FooBar"));
    String oldName = Thread.currentThread().getName();
    renamingExecutor.execute(
        new Runnable() {
          @Override
          public void run() {
            assertEquals("FooBar", Thread.currentThread().getName());
          }
        });

 *
 * This class would integrate with DiSNI to provide registered
 * memory regions for high-performance RDMA operations.
 *
 * Note: This is a skeleton implementation. A real implementation would
 * require proper DiSNI integration with actual memory registration.
 */
public class DisniMemoryRegion extends RdmaMemoryRegion {

    private static final Logger log = LoggerFactory.getLogger(DisniMemoryRegion.class);

    this.target = checkNotNull(target);
    this.method = method;
    method.setAccessible(true);

    this.executor = bus.executor();
  }

  /** Dispatches {@code event} to this subscriber using the proper executor. */
  final void dispatchEvent(Object event) {
    executor.execute(
        () -> {
          try {
            invokeSubscriberMethod(event);
          } catch (InvocationTargetException e) {

        // Verify tree handle was acquired
        verify(treeHandle).acquire();

        // Cleanup
        iterator.close();
    }

    // Helper method to create SMB URLs with proper handler
    private static URL createSmbURL(String urlString) throws MalformedURLException {
        return new URL(null, urlString, new jcifs.smb.Handler());
    }

            return null;
        }
    }

    private static int invokeProtectedInt(Object target, String name, Object... params) {
        try {
            var cls = target.getClass();
            // Build proper parameter types array, handling primitive types
            Class<?>[] paramTypes = new Class<?>[params.length];
            for (int i = 0; i < params.length; i++) {
                if (params[i] instanceof byte[]) {

        final Map<String, Object> bindingMap = new HashMap<>(safeParamMap);
        bindingMap.put("container", SingletonLaContainerFactory.getContainer());

        // Create GroovyShell with custom class loader for proper resource management
        GroovyClassLoader classLoader = null;
        try {
            // Get parent class loader with fallback to ensure robustness across threading contexts

### Transition Status

 * This class extends {@link BasePooledObjectFactory} and provides
 * methods for creating, wrapping, and destroying crawler components
 * obtained from a {@link CrawlerContainer}.
 *
 * <p>This implementation provides proper resource management for closeable objects
 * and supports destruction listeners.</p>
 *
 * @param <T> the type of the pooled object
 */
public class CrawlerPooledObjectFactory<T> extends BasePooledObjectFactory<T> {