Wire loader to support ModuleRegistry alongside ExtensionSpecification

Phase 3a: Add dual-path instance creation to the AppLoader.

- Add ModuleRegistry field to AppLoader
- Update createExtensionInstance to check registry first via
  descriptor.createModule(), falling back to legacy spec path
- Add createModuleFromDescriptor method for the new path
- Widen findEntryPath signature to accept both specs and descriptors
- Add moduleRegistry to ConfigurationLoaderResult type

The registry is currently empty so all instances still use the legacy
SpecificationBackedExtension path. Next PR will migrate actual specs.

Author: isaacroldan

packages/app/src/cli/models/app/loader.ts

@@ -21,6 +21,7 @@ import {
 import {configurationFileNames, dotEnvFileNames} from '../../constants.js'
 import metadata from '../../metadata.js'
 import {ExtensionInstance, SpecificationBackedExtension} from '../extensions/extension-instance.js'
+import {ModuleRegistry} from '../extensions/module-registry.js'
 import {ExtensionsArraySchema, UnifiedSchema} from '../extensions/schemas.js'
 import {ExtensionSpecification, isAppConfigSpecification} from '../extensions/specification.js'
 import {CreateAppOptions, Flag} from '../../utilities/developer-platform-client.js'
@@ -459,6 +460,7 @@ class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends Ext
   private readonly loadedConfiguration: ConfigurationLoaderResult<TConfig, TModuleSpec>
   private readonly reloadState: ReloadState | undefined
   private readonly project: Project
+  private readonly moduleRegistry: ModuleRegistry
 
   constructor({
     ignoreUnknownExtensions,
@@ -472,6 +474,7 @@ class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends Ext
     this.loadedConfiguration = loadedConfiguration
     this.reloadState = reloadState
     this.project = project
+    this.moduleRegistry = loadedConfiguration.moduleRegistry ?? new ModuleRegistry()
   }
 
   private get activeConfigFile(): TomlFile | undefined {
@@ -587,6 +590,14 @@ class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends Ext
     configurationPath: string,
     directory: string,
   ): Promise<ExtensionInstance | undefined> {
+    // Check the module registry first (new subclass-based path).
+    // If a descriptor is found, use its factory to create the right subclass.
+    const descriptor = this.moduleRegistry.findForType(type)
+    if (descriptor) {
+      return this.createModuleFromDescriptor(descriptor, configurationObject, configurationPath, directory)
+    }
+
+    // Fall back to legacy ExtensionSpecification path.
     const specification = this.findSpecificationForType(type)
     let entryPath
     let usedKnownSpecification = false
@@ -642,6 +653,62 @@ class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends Ext
     return extensionInstance
   }
 
+  private async createModuleFromDescriptor(
+    descriptor: ReturnType<ModuleRegistry['findForType']> & {},
+    configurationObject: object,
+    configurationPath: string,
+    directory: string,
+  ): Promise<ExtensionInstance | undefined> {
+    const parseResult = descriptor.parseConfigurationObject(configurationObject)
+    if (parseResult.state === 'error') {
+      if (parseResult.errors) {
+        for (const error of parseResult.errors) {
+          this.errors.addError({
+            file: configurationPath,
+            message: error.message ?? `Validation error at ${error.path.join('.')}`,
+          })
+        }
+      }
+      return undefined
+    }
+
+    const configuration = parseResult.data
+    const entryPath = await this.findEntryPath(directory, descriptor)
+
+    const moduleInstance = descriptor.createModule({
+      configuration,
+      configurationPath,
+      entryPath,
+      directory,
+      remoteSpec: {
+        name: descriptor.externalName,
+        externalName: descriptor.externalName,
+        identifier: descriptor.identifier,
+        gated: false,
+        externalIdentifier: descriptor.externalIdentifier,
+        experience: descriptor.experience,
+        managementExperience: 'cli',
+        registrationLimit: descriptor.registrationLimit,
+        uidStrategy: descriptor.uidStrategy,
+        surface: descriptor.surface,
+      },
+    })
+
+    if (this.reloadState && configuration.handle) {
+      const previousDevUUID = this.reloadState.extensionDevUUIDs.get(configuration.handle)
+      if (previousDevUUID) {
+        moduleInstance.devUUID = previousDevUUID
+      }
+    }
+
+    const validateResult = await moduleInstance.validate()
+    if (validateResult.isErr()) {
+      this.errors.addError({file: configurationPath, message: stringifyMessage(validateResult.error).trim()})
+    }
+
+    return moduleInstance
+  }
+
   private async loadExtensions(appDirectory: string, appConfiguration: TConfig): Promise<ExtensionInstance[]> {
     if (this.specifications.length === 0) return []
 
@@ -820,9 +887,10 @@ class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends Ext
     return configContent ? extensionInstance : undefined
   }
 
-  private async findEntryPath(directory: string, specification: ExtensionSpecification) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private async findEntryPath(directory: string, specification: {identifier: string; appModuleFeatures?: (...args: any[]) => string[]}) {
     let entryPath
-    if (specification.appModuleFeatures().includes('single_js_entry_path')) {
+    if (specification.appModuleFeatures?.().includes('single_js_entry_path')) {
       entryPath = (
         await Promise.all(
           ['index']
@@ -890,6 +958,7 @@ type ConfigurationLoaderResult<
   TModuleSpec extends ExtensionSpecification,
 > = AppConfigurationInterface<TConfig, TModuleSpec> & {
   configurationLoadResultMetadata: ConfigurationLoadResultMetadata
+  moduleRegistry?: ModuleRegistry
 }
 
 /**