assign-gingerly 0.0.71 → 0.0.73

package/assignPermissions/restrictedProps.ts

@@ -0,0 +1,53 @@
+import type { AssignPermissions, RestrictedPropSetting } from '../types/assign-gingerly/types.js';
+
+export type RestrictedPropSettingsMap = Map<string, RestrictedPropSetting | undefined>;
+
+const warnedOnce = new Set<string>();
+
+function warnRestricted(key: string): void {
+    if (!warnedOnce.has(key)) {
+        warnedOnce.add(key);
+        console.warn(`assignGingerly: property '${key}' is in restrictedPropSettings — assignment skipped.`);
+    }
+}
+
+export function buildRestrictedPropSet(permissions: AssignPermissions | undefined): RestrictedPropSettingsMap | undefined {
+    const settings = permissions?.restrictedPropSettings;
+    if (!settings || settings.length === 0) return undefined;
+    const restrictedPropSet: RestrictedPropSettingsMap = new Map();
+    for (const setting of settings) {
+        const prop = typeof setting === 'string' ? setting : setting.prop;
+        if (restrictedPropSet.has(prop)) {
+            throw new Error(`assignGingerly: duplicate restrictedPropSettings entry for '${prop}'.`);
+        }
+        restrictedPropSet.set(prop, typeof setting === 'string' ? undefined : setting);
+    }
+    return restrictedPropSet;
+}
+
+export function checkRestrictedProp(restrictedPropSet: RestrictedPropSettingsMap | undefined, key: string): boolean {
+    if (!restrictedPropSet || !restrictedPropSet.has(key)) return false;
+    warnRestricted(key);
+    return true;
+}
+
+export function redirectRestrictedProp(
+    restrictedPropSet: RestrictedPropSettingsMap | undefined,
+    target: any,
+    key: string,
+    value: any
+): boolean {
+    if (!restrictedPropSet || !restrictedPropSet.has(key)) return false;
+    const setting = restrictedPropSet.get(key);
+    if (!setting?.useMethod) {
+        warnRestricted(key);
+        return true;
+    }
+    const method = target?.[setting.useMethod];
+    if (typeof method !== 'function') {
+        warnRestricted(key);
+        return true;
+    }
+    method.call(target, value);
+    return true;
+}

package/assignTentatively.js

@@ -1,3 +1,4 @@
+import { buildRestrictedPropSet, checkRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Helper function to check if a string key represents an += command
  */
@@ -13,6 +14,23 @@ function parseIncCommand(key) {
     }
     return key.substring(0, key.length - 3); // Remove ' +=' suffix
 }
+/**
+ * Apply the scalar and array semantics of the += command.
+ */
+function addValue(lhs, rhs) {
+    if (Array.isArray(lhs)) {
+        return Array.isArray(rhs) ? [...lhs, ...rhs] : [...lhs, rhs];
+    }
+    if (typeof lhs === 'number' && typeof rhs === 'string') {
+        const parsed = Number(rhs);
+        return Number.isNaN(parsed) ? lhs + rhs : lhs + parsed;
+    }
+    if (typeof lhs === 'string' && typeof rhs === 'number') {
+        const parsed = Number(lhs);
+        return Number.isNaN(parsed) ? lhs + rhs : (parsed + rhs).toString();
+    }
+    return lhs + rhs;
+}
 /**
  * Helper function to check if a key represents a =! command
  */
@@ -96,12 +114,13 @@ function getTopLevelKey(path) {
 /**
  * Main assignTentatively function with reversal support
  */
-export function assignTentatively(target, source, options) {
+export function assignTentatively(target, source, options, permissions) {
     if (!target || typeof target !== 'object') {
         return target;
     }
     const reversal = options?.reversal || {};
     const trackedCreatedPaths = new Set();
+    const restrictedPropSet = buildRestrictedPropSet(permissions);
     // Process all keys from source
     for (const key of Object.keys(source)) {
         const value = source[key];
@@ -112,11 +131,14 @@ export function assignTentatively(target, source, options) {
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
                     const topLevelKey = pathParts[0];
+                    const lastKey = pathParts[pathParts.length - 1];
+                    if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+                        continue;
+                    }
                     // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
                     if (!(topLevelKey in target)) {
                         trackedCreatedPaths.add(topLevelKey);
                     }
-                    const lastKey = pathParts[pathParts.length - 1];
                     const parent = ensureNestedPath(target, pathParts);
                     // If property already exists, store original value for reversal
                     if (lastKey in parent) {
@@ -124,18 +146,7 @@ export function assignTentatively(target, source, options) {
                         if (!(fullPath in reversal)) {
                             reversal[fullPath] = parent[lastKey];
                         }
-                        if (Array.isArray(parent[lastKey])) {
-                            parent[lastKey] = Array.isArray(value)
-                                ? [...parent[lastKey], ...value]
-                                : [...parent[lastKey], value];
-                        }
-                        else if (typeof parent[lastKey] === 'number' && typeof value === 'string') {
-                            const parsed = Number(value);
-                            parent[lastKey] = isNaN(parsed) ? parent[lastKey] + value : parent[lastKey] + parsed;
-                        }
-                        else {
-                            parent[lastKey] += value;
-                        }
+                        parent[lastKey] = addValue(parent[lastKey], value);
                     }
                     else {
                         // Property doesn't exist, create it with the value
@@ -144,22 +155,14 @@ export function assignTentatively(target, source, options) {
                 }
                 else {
                     // Plain key - direct operation on target
+                    if (checkRestrictedProp(restrictedPropSet, path)) {
+                        continue;
+                    }
                     if (path in target) {
                         if (!(path in reversal)) {
                             reversal[path] = target[path];
                         }
-                        if (Array.isArray(target[path])) {
-                            target[path] = Array.isArray(value)
-                                ? [...target[path], ...value]
-                                : [...target[path], value];
-                        }
-                        else if (typeof target[path] === 'number' && typeof value === 'string') {
-                            const parsed = Number(value);
-                            target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
-                        }
-                        else {
-                            target[path] += value;
-                        }
+                        target[path] = addValue(target[path], value);
                     }
                     else {
                         target[path] = value;
@@ -179,16 +182,22 @@ export function assignTentatively(target, source, options) {
                 if (isNestedPath(lhsPath)) {
                     lhsPathParts = parsePath(lhsPath);
                     const topLevelKey = lhsPathParts[0];
+                    lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+                    if (checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+                        continue;
+                    }
                     // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
                     if (!(topLevelKey in target)) {
                         trackedCreatedPaths.add(topLevelKey);
                     }
-                    lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
                     lhsParent = ensureNestedPath(target, lhsPathParts);
                 }
                 else {
                     lhsPathParts = [lhsPath];
                     lhsLastKey = lhsPath;
+                    if (checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+                        continue;
+                    }
                     lhsParent = target;
                 }
                 // Determine what to negate
@@ -291,11 +300,14 @@ export function assignTentatively(target, source, options) {
         if (isNestedPath(key)) {
             const pathParts = parsePath(key);
             const topLevelKey = pathParts[0];
+            const lastKey = pathParts[pathParts.length - 1];
+            if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+                continue;
+            }
             // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
             if (!(topLevelKey in target)) {
                 trackedCreatedPaths.add(topLevelKey);
             }
-            const lastKey = pathParts[pathParts.length - 1];
             const parent = ensureNestedPath(target, pathParts);
             if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                 // Recursively apply assignTentatively for nested objects
@@ -311,7 +323,7 @@ export function assignTentatively(target, source, options) {
                 }
                 // For nested objects, recursively apply with nested reversal tracking
                 const nestedReversal = {};
-                assignTentatively(parent[lastKey], value, { reversal: nestedReversal });
+                assignTentatively(parent[lastKey], value, { reversal: nestedReversal }, permissions);
                 // Merge nested reversals
                 for (const revKey of Object.keys(nestedReversal)) {
                     if (!(revKey in reversal)) {
@@ -332,6 +344,9 @@ export function assignTentatively(target, source, options) {
         }
         else {
             // Non-nested key
+            if (checkRestrictedProp(restrictedPropSet, key)) {
+                continue;
+            }
             if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                 // Recursively apply assignTentatively for nested objects
                 if (!(key in target) || typeof target[key] !== 'object') {
@@ -344,7 +359,7 @@ export function assignTentatively(target, source, options) {
                     target[key] = {};
                 }
                 const nestedReversal = {};
-                assignTentatively(target[key], value, { reversal: nestedReversal });
+                assignTentatively(target[key], value, { reversal: nestedReversal }, permissions);
                 // Merge nested reversals
                 for (const revKey of Object.keys(nestedReversal)) {
                     if (!(revKey in reversal)) {

package/assignTentatively.ts

@@ -1,7 +1,9 @@
 /**
  * assignTentatively — reversible assignment with change tracking.
  */
-import type { IAssignTentativelyOptions } from './types/assign-gingerly/types.js';
+import type { IAssignTentativelyOptions } from './types/assign-gingerly/types.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
+import { buildRestrictedPropSet, checkRestrictedProp } from './assignPermissions/restrictedProps.js';
 export type { IAssignTentativelyOptions };
 
 /**
@@ -14,12 +16,30 @@ function isIncCommand(key: string): boolean {
 /**
  * Helper function to parse an += command and extract the path
  */
-function parseIncCommand(key: string): string | null {
-  if (!isIncCommand(key)) {
-    return null;
-  }
-  return key.substring(0, key.length - 3); // Remove ' +=' suffix
-}
+function parseIncCommand(key: string): string | null {
+  if (!isIncCommand(key)) {
+    return null;
+  }
+  return key.substring(0, key.length - 3); // Remove ' +=' suffix
+}
+
+/**
+ * Apply the scalar and array semantics of the += command.
+ */
+function addValue(lhs: any, rhs: any): any {
+  if (Array.isArray(lhs)) {
+    return Array.isArray(rhs) ? [...lhs, ...rhs] : [...lhs, rhs];
+  }
+  if (typeof lhs === 'number' && typeof rhs === 'string') {
+    const parsed = Number(rhs);
+    return Number.isNaN(parsed) ? lhs + rhs : lhs + parsed;
+  }
+  if (typeof lhs === 'string' && typeof rhs === 'number') {
+    const parsed = Number(lhs);
+    return Number.isNaN(parsed) ? lhs + rhs : (parsed + rhs).toString();
+  }
+  return lhs + rhs;
+}
 
 /**
  * Helper function to check if a key represents a =! command
@@ -114,16 +134,18 @@ function getTopLevelKey(path: string): string | null {
  * Main assignTentatively function with reversal support
  */
 export function assignTentatively(
-  target: any,
-  source: Record<string | symbol, any>,
-  options?: IAssignTentativelyOptions
-): any {
+  target: any,
+  source: Record<string | symbol, any>,
+  options?: IAssignTentativelyOptions,
+  permissions?: AssignPermissions
+): any {
   if (!target || typeof target !== 'object') {
     return target;
   }
 
-  const reversal = options?.reversal || {};
-  const trackedCreatedPaths = new Set<string>();
+  const reversal = options?.reversal || {};
+  const trackedCreatedPaths = new Set<string>();
+  const restrictedPropSet = buildRestrictedPropSet(permissions);
 
   // Process all keys from source
   for (const key of Object.keys(source)) {
@@ -133,17 +155,21 @@ export function assignTentatively(
     if (isIncCommand(key)) {
       const path = parseIncCommand(key);
       if (path) {
-        if (isNestedPath(path)) {
-          const pathParts = parsePath(path);
-          const topLevelKey = pathParts[0];
+        if (isNestedPath(path)) {
+          const pathParts = parsePath(path);
+          const topLevelKey = pathParts[0];
+          const lastKey = pathParts[pathParts.length - 1];
+
+          if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+            continue;
+          }
           
           // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
           if (!(topLevelKey in target)) {
             trackedCreatedPaths.add(topLevelKey);
           }
           
-          const lastKey = pathParts[pathParts.length - 1];
-          const parent = ensureNestedPath(target, pathParts);
+          const parent = ensureNestedPath(target, pathParts);
 
           // If property already exists, store original value for reversal
           if (lastKey in parent) {
@@ -151,36 +177,21 @@ export function assignTentatively(
             if (!(fullPath in reversal)) {
               reversal[fullPath] = parent[lastKey];
             }
-            if (Array.isArray(parent[lastKey])) {
-              parent[lastKey] = Array.isArray(value)
-                ? [...parent[lastKey], ...value]
-                : [...parent[lastKey], value];
-            } else if (typeof parent[lastKey] === 'number' && typeof value === 'string') {
-              const parsed = Number(value);
-              parent[lastKey] = isNaN(parsed) ? parent[lastKey] + value : parent[lastKey] + parsed;
-            } else {
-              parent[lastKey] += value;
-            }
+            parent[lastKey] = addValue(parent[lastKey], value);
           } else {
             // Property doesn't exist, create it with the value
             parent[lastKey] = value;
           }
-        } else {
-          // Plain key - direct operation on target
-          if (path in target) {
+        } else {
+          // Plain key - direct operation on target
+          if (checkRestrictedProp(restrictedPropSet, path)) {
+            continue;
+          }
+          if (path in target) {
             if (!(path in reversal)) {
               reversal[path] = target[path];
             }
-            if (Array.isArray(target[path])) {
-              target[path] = Array.isArray(value)
-                ? [...target[path], ...value]
-                : [...target[path], value];
-            } else if (typeof target[path] === 'number' && typeof value === 'string') {
-              const parsed = Number(value);
-              target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
-            } else {
-              target[path] += value;
-            }
+            target[path] = addValue(target[path], value);
           } else {
             target[path] = value;
           }
@@ -199,21 +210,28 @@ export function assignTentatively(
         let lhsLastKey: string;
         let lhsPathParts: string[];
         
-        if (isNestedPath(lhsPath)) {
-          lhsPathParts = parsePath(lhsPath);
-          const topLevelKey = lhsPathParts[0];
+        if (isNestedPath(lhsPath)) {
+          lhsPathParts = parsePath(lhsPath);
+          const topLevelKey = lhsPathParts[0];
+          lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+
+          if (checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+            continue;
+          }
           
           // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
           if (!(topLevelKey in target)) {
             trackedCreatedPaths.add(topLevelKey);
           }
           
-          lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
-          lhsParent = ensureNestedPath(target, lhsPathParts);
-        } else {
-          lhsPathParts = [lhsPath];
-          lhsLastKey = lhsPath;
-          lhsParent = target;
+          lhsParent = ensureNestedPath(target, lhsPathParts);
+        } else {
+          lhsPathParts = [lhsPath];
+          lhsLastKey = lhsPath;
+          if (checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+            continue;
+          }
+          lhsParent = target;
         }
 
         // Determine what to negate
@@ -314,17 +332,21 @@ export function assignTentatively(
       continue;
     }
 
-    if (isNestedPath(key)) {
-      const pathParts = parsePath(key);
-      const topLevelKey = pathParts[0];
+    if (isNestedPath(key)) {
+      const pathParts = parsePath(key);
+      const topLevelKey = pathParts[0];
+      const lastKey = pathParts[pathParts.length - 1];
+
+      if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+        continue;
+      }
 
       // Track if we created a new top-level path (BEFORE calling ensureNestedPath)
       if (!(topLevelKey in target)) {
         trackedCreatedPaths.add(topLevelKey);
       }
       
-      const lastKey = pathParts[pathParts.length - 1];
-      const parent = ensureNestedPath(target, pathParts);
+      const parent = ensureNestedPath(target, pathParts);
 
       if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
         // Recursively apply assignTentatively for nested objects
@@ -340,7 +362,7 @@ export function assignTentatively(
         }
         // For nested objects, recursively apply with nested reversal tracking
         const nestedReversal: Record<string | symbol, any> = {};
-        assignTentatively(parent[lastKey], value, { reversal: nestedReversal });
+        assignTentatively(parent[lastKey], value, { reversal: nestedReversal }, permissions);
         // Merge nested reversals
         for (const revKey of Object.keys(nestedReversal)) {
           if (!(revKey in reversal)) {
@@ -357,9 +379,12 @@ export function assignTentatively(
         }
         parent[lastKey] = value;
       }
-    } else {
-      // Non-nested key
-      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+    } else {
+      // Non-nested key
+      if (checkRestrictedProp(restrictedPropSet, key)) {
+        continue;
+      }
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
         // Recursively apply assignTentatively for nested objects
         if (!(key in target) || typeof target[key] !== 'object') {
           // Store original value for reversal if it existed
@@ -371,7 +396,7 @@ export function assignTentatively(
           target[key] = {};
         }
         const nestedReversal: Record<string | symbol, any> = {};
-        assignTentatively(target[key], value, { reversal: nestedReversal });
+        assignTentatively(target[key], value, { reversal: nestedReversal }, permissions);
         // Merge nested reversals
         for (const revKey of Object.keys(nestedReversal)) {
           if (!(revKey in reversal)) {

package/defineWithFeatures.js

@@ -73,29 +73,33 @@ export async function defineWithFeatures(tagName, baseTagName, config, registry,
         classCache = new Map();
         resolvedSpawnCache.set(BaseClass, classCache);
     }
-    const featureKeys = Object.keys(config.assignFeatures);
-    const 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);
-    }));
+    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
     const NewClass = class extends BaseClass {
     };
@@ -103,16 +107,18 @@ export async function defineWithFeatures(tagName, baseTagName, config, registry,
     if (options?.onSubclassCreated) {
         options.onSubclassCreated(NewClass);
     }
-    // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-    const featuresMap = {};
-    for (const [key, jsonConfig] of Object.entries(config.assignFeatures)) {
-        featuresMap[key] = {
-            spawn: resolvedSpawns.get(key),
-            ...jsonConfig
-        };
+    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);
     }
-    // 5. assignFeatures (sequential onAssigned) + define
-    await assignFeatures(NewClass, featuresMap, reg.featuresRegistry);
     reg.define(tagName, NewClass);
     return NewClass;
 }

package/defineWithFeatures.ts

@@ -104,56 +104,63 @@ export async function defineWithFeatures(
         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);
+        }));
+    }
 
-    const featureKeys = Object.keys(config.assignFeatures);
-    const 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) {};
+    const NewClass = class extends (BaseClass as any) { };
 
     // 3b. Call onSubclassCreated callback (before define, before features if needed)
     if (options?.onSubclassCreated) {
         options.onSubclassCreated(NewClass);
     }
 
-    // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-    const featuresMap: FeatureConfigsMap = {};
-    for (const [key, jsonConfig] of Object.entries(config.assignFeatures)) {
-        featuresMap[key] = {
-            spawn: resolvedSpawns.get(key),
-            ...jsonConfig
-        };
+    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);
     }
 
-    // 5. assignFeatures (sequential onAssigned) + define
-    await assignFeatures(NewClass, featuresMap, (reg as any).featuresRegistry);
     (reg as any).define(tagName, NewClass);
 
     return NewClass;