assign-gingerly 0.0.73 → 0.0.74

package/defineWithFeatures.js

@@ -1,9 +1,9 @@
 /**
  * defineWithFeatures - Declaratively define a custom element with features from JSON config.
  *
- * Resolves async fallback spawns from the base class's `static supportedFeatures`,
- * creates a subclass, registers features with resolved spawns + JSON config,
- * and defines the custom element.
+ * A thin wrapper around assignFeatures: waits for the base class, creates a subclass,
+ * optionally calls onSubclassCreated, awaits assignFeatures(NewClass, config.assignFeatures),
+ * then defines the custom element in the registry.
  *
  * Designed to support cede scripts and other declarative custom element definition patterns.
  *
@@ -20,30 +20,13 @@
  * });
  */
 import { assignFeatures } from './assignFeatures.js';
-/**
- * Determines if a function is an async spawner (same heuristic as assignFeatures).
- */
-function isAsyncSpawn(fn) {
-    if (typeof fn !== 'function')
-        return false;
-    if (fn.constructor.name === 'AsyncFunction')
-        return true;
-    if (fn.prototype === undefined)
-        return true;
-    return false;
-}
-/**
- * Cache for resolved fallback spawns.
- * Key: BaseClass, Value: Map<featureKey, resolvedConstructor>
- */
-const resolvedSpawnCache = new WeakMap();
 /**
  * Declaratively define a custom element with features.
  *
  * 1. Waits for the base class to be defined (if not already).
- * 2. Resolves all async fallback spawns from `static supportedFeatures`.
- * 3. Creates a subclass extending the base class.
- * 4. Calls `assignFeatures` with resolved spawns + the JSON config.
+ * 2. Creates a subclass extending the base class.
+ * 3. Calls the optional onSubclassCreated callback.
+ * 4. Calls assignFeatures with the JSON config and the registry's featuresRegistry.
  * 5. Defines the new custom element in the registry.
  *
  * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
@@ -63,62 +46,19 @@ export async function defineWithFeatures(tagName, baseTagName, config, registry,
     if (!BaseClass) {
         throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
     }
-    const supportedFeatures = BaseClass.supportedFeatures;
-    if (!supportedFeatures) {
-        throw new Error(`defineWithFeatures: "${baseTagName}" does not define static supportedFeatures`);
-    }
-    // 2. Resolve all async fallback spawns (with caching)
-    let classCache = resolvedSpawnCache.get(BaseClass);
-    if (!classCache) {
-        classCache = new Map();
-        resolvedSpawnCache.set(BaseClass, classCache);
-    }
-    const { assignFeatures: af } = config;
-    let resolvedSpawns;
-    if (af) {
-        const featureKeys = Object.keys(af);
-        resolvedSpawns = new Map();
-        await Promise.all(featureKeys.map(async (key) => {
-            const optIn = supportedFeatures[key];
-            if (!optIn) {
-                throw new Error(`defineWithFeatures: feature "${key}" not found in ${baseTagName}.supportedFeatures`);
-            }
-            // Check cache first
-            if (classCache.has(key)) {
-                resolvedSpawns.set(key, classCache.get(key));
-                return;
-            }
-            let spawn = optIn.fallbackSpawn;
-            if (spawn && isAsyncSpawn(spawn)) {
-                // Resolve the async spawner
-                spawn = await spawn();
-            }
-            // Cache the resolved spawn
-            if (spawn) {
-                classCache.set(key, spawn);
-            }
-            resolvedSpawns.set(key, spawn);
-        }));
-    }
-    // 3. Create subclass
+    // 2. Create subclass
     const NewClass = class extends BaseClass {
     };
-    // 3b. Call onSubclassCreated callback (before define, before features if needed)
+    // 3. Optional subclass callback
     if (options?.onSubclassCreated) {
         options.onSubclassCreated(NewClass);
     }
+    // 4. Assign features (assignFeatures resolves all spawns and installs getters)
+    const { assignFeatures: af } = config;
     if (af) {
-        // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-        const featuresMap = {};
-        for (const [key, jsonConfig] of Object.entries(af)) {
-            featuresMap[key] = {
-                spawn: resolvedSpawns.get(key),
-                ...jsonConfig
-            };
-        }
-        // 5. assignFeatures (sequential onAssigned) + define
-        await assignFeatures(NewClass, featuresMap, reg.featuresRegistry);
+        await assignFeatures(NewClass, af, reg.featuresRegistry);
     }
+    // 5. Define the custom element
     reg.define(tagName, NewClass);
     return NewClass;
 }

package/defineWithFeatures.ts

@@ -1,167 +1,92 @@
-/**
- * defineWithFeatures - Declaratively define a custom element with features from JSON config.
- * 
- * Resolves async fallback spawns from the base class's `static supportedFeatures`,
- * creates a subclass, registers features with resolved spawns + JSON config,
- * and defines the custom element.
- * 
- * Designed to support cede scripts and other declarative custom element definition patterns.
- * 
- * @example
- * await defineWithFeatures('time-ticker', 'el-maker', {
- *     assignFeatures: {
- *         timeTicker: {},
- *         roundabout: {
- *             customData: {...},
- *             withAttrs: {...},
- *             callbackForwarding: ['connectedCallback']
- *         }
- *     }
- * });
- */
-
-import { assignFeatures, FeatureConfigsMap, SupportedFeaturesMap } from './assignFeatures.js';
-
-/**
- * Configuration passed to defineWithFeatures (JSON-serializable).
- */
-export interface DefineWithFeaturesConfig {
-    assignFeatures: Record<string, {
-        customData?: any;
-        withAttrs?: any;
-        callbackForwarding?: string[];
-    }>;
-}
-
-/**
- * Options for defineWithFeatures.
- */
-export interface DefineWithFeaturesOptions {
-    /** Called after the subclass is created but before registry.define(). */
-    onSubclassCreated?: (NewCtr: Function) => void;
-}
-
-/**
- * Determines if a function is an async spawner (same heuristic as assignFeatures).
- */
-function isAsyncSpawn(fn: any): boolean {
-    if (typeof fn !== 'function') return false;
-    if (fn.constructor.name === 'AsyncFunction') return true;
-    if (fn.prototype === undefined) return true;
-    return false;
-}
-
-/**
- * Cache for resolved fallback spawns.
- * Key: BaseClass, Value: Map<featureKey, resolvedConstructor>
- */
-const resolvedSpawnCache = new WeakMap<Function, Map<string, any>>();
-
-/**
- * Declaratively define a custom element with features.
- * 
- * 1. Waits for the base class to be defined (if not already).
- * 2. Resolves all async fallback spawns from `static supportedFeatures`.
- * 3. Creates a subclass extending the base class.
- * 4. Calls `assignFeatures` with resolved spawns + the JSON config.
- * 5. Defines the new custom element in the registry.
- * 
- * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
- * @param baseTagName - The tag name of the base class to extend (e.g., 'el-maker')
- * @param config - JSON-serializable configuration specifying which features to activate
- * @param registry - Optional custom element registry (defaults to global `customElements`)
- * @returns The newly created and defined custom element class
- */
-export async function defineWithFeatures(
-    tagName: string,
-    baseTagName: string,
-    config: DefineWithFeaturesConfig,
-    registry?: CustomElementRegistry,
-    options?: DefineWithFeaturesOptions
-): Promise<Function> {
-    const reg = registry || customElements;
-
-    // 1. Resolve base class — wait for it if not yet defined
-    let BaseClass = (reg as any).get(baseTagName);
-    if (!BaseClass) {
-        await (reg as any).whenDefined(baseTagName);
-        BaseClass = (reg as any).get(baseTagName);
-    }
-    if (!BaseClass) {
-        throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
-    }
-
-    const supportedFeatures: SupportedFeaturesMap | undefined = BaseClass.supportedFeatures;
-    if (!supportedFeatures) {
-        throw new Error(
-            `defineWithFeatures: "${baseTagName}" does not define static supportedFeatures`
-        );
-    }
-
-    // 2. Resolve all async fallback spawns (with caching)
-    let classCache = resolvedSpawnCache.get(BaseClass);
-    if (!classCache) {
-        classCache = new Map();
-        resolvedSpawnCache.set(BaseClass, classCache);
-    }
-    const {assignFeatures: af} = config;
-    let resolvedSpawns: Map<string, any> | undefined;
-    if (af) {
-        const featureKeys = Object.keys(af);
-        resolvedSpawns = new Map<string, any>();
-
-        await Promise.all(featureKeys.map(async (key) => {
-            const optIn = supportedFeatures[key];
-            if (!optIn) {
-                throw new Error(
-                    `defineWithFeatures: feature "${key}" not found in ${baseTagName}.supportedFeatures`
-                );
-            }
-
-            // Check cache first
-            if (classCache!.has(key)) {
-                resolvedSpawns!.set(key, classCache!.get(key));
-                return;
-            }
-
-            let spawn = optIn.fallbackSpawn;
-            if (spawn && isAsyncSpawn(spawn)) {
-                // Resolve the async spawner
-                spawn = await (spawn as () => Promise<any>)();
-            }
-
-            // Cache the resolved spawn
-            if (spawn) {
-                classCache!.set(key, spawn);
-            }
-            resolvedSpawns!.set(key, spawn);
-        }));
-    }
-
-
-    // 3. Create subclass
-    const NewClass = class extends (BaseClass as any) { };
-
-    // 3b. Call onSubclassCreated callback (before define, before features if needed)
-    if (options?.onSubclassCreated) {
-        options.onSubclassCreated(NewClass);
-    }
-
-    if(af){
-        // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-        const featuresMap: FeatureConfigsMap = {};
-        for (const [key, jsonConfig] of Object.entries(af)) {
-            featuresMap[key] = {
-                spawn: resolvedSpawns!.get(key),
-                ...jsonConfig
-            };
-        }
-
-        // 5. assignFeatures (sequential onAssigned) + define
-        await assignFeatures(NewClass, featuresMap, (reg as any).featuresRegistry);
-    }
-
-    (reg as any).define(tagName, NewClass);
-
-    return NewClass;
-}
+/**
+ * defineWithFeatures - Declaratively define a custom element with features from JSON config.
+ * 
+ * A thin wrapper around assignFeatures: waits for the base class, creates a subclass,
+ * optionally calls onSubclassCreated, awaits assignFeatures(NewClass, config.assignFeatures),
+ * then defines the custom element in the registry.
+ * 
+ * Designed to support cede scripts and other declarative custom element definition patterns.
+ * 
+ * @example
+ * await defineWithFeatures('time-ticker', 'el-maker', {
+ *     assignFeatures: {
+ *         timeTicker: {},
+ *         roundabout: {
+ *             customData: {...},
+ *             withAttrs: {...},
+ *             callbackForwarding: ['connectedCallback']
+ *         }
+ *     }
+ * });
+ */
+
+import { assignFeatures, FeatureConfigsMap } from './assignFeatures.js';
+
+/**
+ * Configuration passed to defineWithFeatures (JSON-serializable).
+ */
+export interface DefineWithFeaturesConfig {
+    assignFeatures: FeatureConfigsMap;
+}
+
+/**
+ * Options for defineWithFeatures.
+ */
+export interface DefineWithFeaturesOptions {
+    /** Called after the subclass is created but before registry.define(). */
+    onSubclassCreated?: (NewCtr: Function) => void;
+}
+
+/**
+ * Declaratively define a custom element with features.
+ * 
+ * 1. Waits for the base class to be defined (if not already).
+ * 2. Creates a subclass extending the base class.
+ * 3. Calls the optional onSubclassCreated callback.
+ * 4. Calls assignFeatures with the JSON config and the registry's featuresRegistry.
+ * 5. Defines the new custom element in the registry.
+ * 
+ * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
+ * @param baseTagName - The tag name of the base class to extend (e.g., 'el-maker')
+ * @param config - JSON-serializable configuration specifying which features to activate
+ * @param registry - Optional custom element registry (defaults to global `customElements`)
+ * @returns The newly created and defined custom element class
+ */
+export async function defineWithFeatures(
+    tagName: string,
+    baseTagName: string,
+    config: DefineWithFeaturesConfig,
+    registry?: CustomElementRegistry,
+    options?: DefineWithFeaturesOptions
+): Promise<Function> {
+    const reg = registry || customElements;
+
+    // 1. Resolve base class — wait for it if not yet defined
+    let BaseClass = (reg as any).get(baseTagName);
+    if (!BaseClass) {
+        await (reg as any).whenDefined(baseTagName);
+        BaseClass = (reg as any).get(baseTagName);
+    }
+    if (!BaseClass) {
+        throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
+    }
+
+    // 2. Create subclass
+    const NewClass = class extends (BaseClass as any) { };
+
+    // 3. Optional subclass callback
+    if (options?.onSubclassCreated) {
+        options.onSubclassCreated(NewClass);
+    }
+
+    // 4. Assign features (assignFeatures resolves all spawns and installs getters)
+    const { assignFeatures: af } = config;
+    if (af) {
+        await assignFeatures(NewClass, af, (reg as any).featuresRegistry);
+    }
+
+    // 5. Define the custom element
+    (reg as any).define(tagName, NewClass);
+
+    return NewClass;
+}

package/enhanceAll.js

@@ -16,6 +16,7 @@
  * ]);
  */
 import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
 /**
  * Apply enhancements in bulk to matching elements within a target.
  *
@@ -85,13 +86,16 @@ async function resolveAndRegister(enhConfig, target) {
         if (existing)
             return existing;
     }
-    // Not registered — dynamically import the spawn module
+    // Not registered — dynamically import the spawn module and extract the spawn class
     if (!spawnPath)
         return null;
-    const spawnModule = await import(spawnPath);
-    const SpawnClass = spawnModule.default ?? Object.values(spawnModule).find((v) => typeof v === 'function' && v.prototype);
-    if (!SpawnClass)
+    let SpawnClass;
+    try {
+        SpawnClass = await findClassPrototypeInPath(spawnPath);
+    }
+    catch {
         return null;
+    }
     // Build and register the registry item
     const registryItem = {
         spawn: SpawnClass,

package/enhanceAll.ts

@@ -17,6 +17,7 @@
  */
 
 import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
 import type { AssignPermissions } from './types/assign-gingerly/types.js';
 
 /**
@@ -112,15 +113,15 @@ async function resolveAndRegister(enhConfig: any, target: Element): Promise<any>
         if (existing) return existing;
     }
 
-    // Not registered — dynamically import the spawn module
+    // Not registered — dynamically import the spawn module and extract the spawn class
     if (!spawnPath) return null;
 
-    const spawnModule = await import(spawnPath);
-    const SpawnClass = spawnModule.default ?? Object.values(spawnModule).find(
-        (v: any) => typeof v === 'function' && v.prototype
-    );
-
-    if (!SpawnClass) return null;
+    let SpawnClass;
+    try {
+        SpawnClass = await findClassPrototypeInPath(spawnPath);
+    } catch {
+        return null;
+    }
 
     // Build and register the registry item
     const registryItem: any = {

package/inferencer/types/assign-gingerly/types.d.ts

@@ -615,7 +615,8 @@ export interface FeatureConfig {
      */
     spawn?:
         | { new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }
-        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>);
+        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>)
+        | string // import path or builtIns.* alias
 
     /** Attribute patterns for parsing element attributes into initVals. */
     withAttrs?: AttrPatterns<any>;

package/inferencer/types/font-face-feature/types.d.ts

@@ -0,0 +1,9 @@
+export interface FontFaceFeatureConfig {
+    fontFamilies: FontFaceConfig | FontFaceConfig[],
+}
+
+export interface FontFaceConfig {
+    name: string,
+    url: string,
+    descriptors: FontFaceDescriptors,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -148,6 +148,14 @@
       "default": "./assignPermissions/isAllowedImportPath.js",
       "types": "./assignPermissions/isAllowedImportPath.ts"
     },
+    "./utils/findClassPrototypeInPath.js": {
+      "default": "./utils/findClassPrototypeInPath.js",
+      "types": "./utils/findClassPrototypeInPath.ts"
+    },
+    "./utils/isAsyncSpawn.js": {
+      "default": "./utils/isAsyncSpawn.js",
+      "types": "./utils/isAsyncSpawn.ts"
+    },
     "./markerUtils.js": {
       "default": "./markerUtils.js",
       "types": "./markerUtils.ts"

package/processHandlerCommands.js

@@ -6,7 +6,7 @@
 import { resolveValues } from './resolveValues.js';
 import { getValues } from './getValues.js';
 import { evaluatePathWithMethods } from './assignGingerly.js';
-import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
 import { buildRestrictedPropSet, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Map of built-in handler names to their module paths.
@@ -21,23 +21,11 @@ const BUILT_IN_MAP = {
     'builtIns.rangeSelector': './handlers/rangeSelector.js',
 };
 /**
- * Find a handler class in a dynamically imported module.
- * Checks default export first, then searches for the first class with `assign` on prototype.
+ * Criteria for locating an assignFrom handler class: must expose an `assign` method
+ * on its prototype.
  */
-function findHandlerInModule(module) {
-    // Check default export first
-    if (module.default && typeof module.default === 'function'
-        && module.default.prototype && 'assign' in module.default.prototype) {
-        return module.default;
-    }
-    // Search other exports
-    for (const key of Object.keys(module)) {
-        const exported = module[key];
-        if (typeof exported === 'function' && exported.prototype && 'assign' in exported.prototype) {
-            return exported;
-        }
-    }
-    return undefined;
+function handlerCriteria(proto) {
+    return 'assign' in proto.prototype;
 }
 /**
  * Cache for loaded built-in handler classes — avoids await on subsequent calls.
@@ -55,16 +43,14 @@ async function loadBuiltIn(name) {
     const path = BUILT_IN_MAP[name];
     if (!path)
         return undefined;
-    const module = await import(path);
-    const cls = findHandlerInModule(module);
-    if (cls)
-        handlerCache.set(name, cls);
+    const cls = await findClassPrototypeInPath(path, handlerCriteria);
+    handlerCache.set(name, cls);
     return cls;
 }
 /**
  * Resolve a handler from options.handlers (class constructor or import path).
  */
-async function resolveFromHandlers(name, handlers, permissions) {
+async function resolveFromHandlers(name, handlers) {
     if (!handlers || !(name in handlers))
         return undefined;
     const entry = handlers[name];
@@ -78,17 +64,8 @@ async function resolveFromHandlers(name, handlers, permissions) {
         if (entry.startsWith('builtIns.')) {
             return loadBuiltIn(entry);
         }
-        // Import path string — validate and dynamically import
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(entry)) {
-            throw new Error(`assignFrom: handler "${name}" has an invalid import path "${entry}". ` +
-                `Only same-origin paths or import-map-covered specifiers are allowed. ` +
-                `Pass { crossDomainImports: true } in permissions to override.`);
-        }
-        const module = await import(entry);
-        const HandlerClass = findHandlerInModule(module);
-        if (!HandlerClass) {
-            throw new Error(`assignFrom: handler "${name}" — module "${entry}" does not export a valid handler class.`);
-        }
+        // Import path string — validate and extract handler class via shared utility
+        const HandlerClass = await findClassPrototypeInPath(entry, handlerCriteria);
         return HandlerClass;
     }
     return undefined;
@@ -180,7 +157,7 @@ export async function processHandlerCommands(target, handlerKeys, pattern, optio
         for (const config of configs) {
             //return; //1.3ms
             // 1. Check options.handlers (local, per-call)
-            let HandlerClass = await resolveFromHandlers(config.do, options.handlers, permissions);
+            let HandlerClass = await resolveFromHandlers(config.do, options.handlers);
             //return; // 1.4
             // 2. Fallback to built-in auto-load
             if (!HandlerClass && config.do.startsWith('builtIns.')) {

package/processHandlerCommands.ts

@@ -7,7 +7,7 @@
 import { resolveValues } from './resolveValues.js';
 import { getValues } from './getValues.js';
 import { evaluatePathWithMethods } from './assignGingerly.js';
-import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
 import { buildRestrictedPropSet, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromOptions, AssignFromHandlerConstructor } from './assignFromAsync.js';
@@ -26,23 +26,11 @@ const BUILT_IN_MAP: Record<string, string> = {
 };
 
 /**
- * Find a handler class in a dynamically imported module.
- * Checks default export first, then searches for the first class with `assign` on prototype.
+ * Criteria for locating an assignFrom handler class: must expose an `assign` method
+ * on its prototype.
  */
-function findHandlerInModule(module: any): AssignFromHandlerConstructor | undefined {
-    // Check default export first
-    if (module.default && typeof module.default === 'function'
-        && module.default.prototype && 'assign' in module.default.prototype) {
-        return module.default;
-    }
-    // Search other exports
-    for (const key of Object.keys(module)) {
-        const exported = module[key];
-        if (typeof exported === 'function' && exported.prototype && 'assign' in exported.prototype) {
-            return exported as AssignFromHandlerConstructor;
-        }
-    }
-    return undefined;
+function handlerCriteria(proto: any): boolean {
+    return 'assign' in proto.prototype;
 }
 
 /**
@@ -60,10 +48,9 @@ async function loadBuiltIn(name: string): Promise<AssignFromHandlerConstructor |
     if (cached) return cached;
     const path = BUILT_IN_MAP[name];
     if (!path) return undefined;
-    const module = await import(path);
-    const cls = findHandlerInModule(module);
-    if (cls) handlerCache.set(name, cls);
-    return cls;
+    const cls = await findClassPrototypeInPath(path, handlerCriteria);
+    handlerCache.set(name, cls);
+    return cls as AssignFromHandlerConstructor;
 }
 
 /**
@@ -71,8 +58,7 @@ async function loadBuiltIn(name: string): Promise<AssignFromHandlerConstructor |
  */
 async function resolveFromHandlers(
     name: string,
-    handlers: Record<string, AssignFromHandlerConstructor | string> | undefined,
-    permissions?: AssignPermissions
+    handlers: Record<string, AssignFromHandlerConstructor | string> | undefined
 ): Promise<AssignFromHandlerConstructor | undefined> {
     if (!handlers || !(name in handlers)) return undefined;
 
@@ -90,22 +76,9 @@ async function resolveFromHandlers(
             return loadBuiltIn(entry);
         }
 
-        // Import path string — validate and dynamically import
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(entry)) {
-            throw new Error(
-                `assignFrom: handler "${name}" has an invalid import path "${entry}". ` +
-                `Only same-origin paths or import-map-covered specifiers are allowed. ` +
-                `Pass { crossDomainImports: true } in permissions to override.`
-            );
-        }
-        const module = await import(entry);
-        const HandlerClass = findHandlerInModule(module);
-        if (!HandlerClass) {
-            throw new Error(
-                `assignFrom: handler "${name}" — module "${entry}" does not export a valid handler class.`
-            );
-        }
-        return HandlerClass;
+        // Import path string — validate and extract handler class via shared utility
+        const HandlerClass = await findClassPrototypeInPath(entry, handlerCriteria);
+        return HandlerClass as AssignFromHandlerConstructor;
     }
 
     return undefined;
@@ -204,7 +177,7 @@ export async function processHandlerCommands(
         for (const config of configs) {
             //return; //1.3ms
             // 1. Check options.handlers (local, per-call)
-            let HandlerClass = await resolveFromHandlers(config.do, options.handlers, permissions);
+            let HandlerClass = await resolveFromHandlers(config.do, options.handlers);
             //return; // 1.4
             // 2. Fallback to built-in auto-load
             if (!HandlerClass && config.do.startsWith('builtIns.')) {