fix(typespec-ts): emit models from filtered IR, drop TCGC import from models renderer

The new pipeline's models renderer was still walking the legacy global emit queue, so it bypassed the adapter's filtered TSCodeModel.models/enums/unions set and reintroduced paging result types like *ListResult onto the public surface.

Switch file selection to the filtered IR and look raw sdk types up only for the legacy declaration/serializer helpers that are still shared with src/modular/emitModels.ts. The production path remains src/codegen/models.ts; the legacy file stays as a rendering helper while this removes the direct TCGC dependency from the codegen layer.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: maorleger

packages/typespec-ts/src/codegen/models.ts

@@ -1,16 +1,7 @@
-import {
-  SdkArrayType,
-  SdkDictionaryType,
-  SdkNullableType,
-  SdkType
-} from "@azure-tools/typespec-client-generator-core";
 import { Project, SourceFile } from "ts-morph";
 import type { TSCodeModel } from "../codemodel/index.js";
 import type { SdkContext } from "../utils/interfaces.js";
-import {
-  flattenPropertyModelMap,
-  emitQueue
-} from "../framework/hooks/sdkTypes.js";
+import { flattenPropertyModelMap } from "../framework/hooks/sdkTypes.js";
 import {
   addSerializationFunctions,
   emitType,
@@ -21,28 +12,69 @@ import {
 /**
  * Emit model, enum, and union files from the code model.
  *
- * Serializers stay on the legacy helpers for now, but file selection and the
- * declaration walk come from the new code model.
+ * Serializers stay on the legacy helpers for now, but model selection comes
+ * from the filtered IR rather than the global TCGC emit queue.
  */
 export function emitModelFiles(
   project: Project,
   codeModel: TSCodeModel,
   sdkContext: SdkContext
 ): SourceFile[] {
-  for (const type of emitQueue) {
-    if (!isGenerableType(type)) {
+  const rawModelLookup = buildRawTypeLookup(sdkContext.sdkPackage.models, sdkContext);
+  const rawEnumLookup = buildRawTypeLookup(sdkContext.sdkPackage.enums, sdkContext);
+  const rawUnionLookup = buildRawTypeLookup(sdkContext.sdkPackage.unions, sdkContext);
+  const includedModelKeys = new Set<string>();
+
+  for (const model of codeModel.models) {
+    const rawModel = rawModelLookup.get(getTypeKey(model.name, model.namespace));
+    if (!rawModel) {
+      continue;
+    }
+
+    includedModelKeys.add(getRawTypeKey(rawModel, sdkContext));
+    const sourceFile = getOrCreateModelsFile(
+      project,
+      codeModel.settings.sourceRoot,
+      model.namespace
+    );
+    emitType(sdkContext, rawModel, sourceFile);
+  }
+
+  for (const enumType of codeModel.enums) {
+    const rawEnum = rawEnumLookup.get(getTypeKey(enumType.name, enumType.namespace));
+    if (!rawEnum) {
+      continue;
+    }
+
+    const sourceFile = getOrCreateModelsFile(
+      project,
+      codeModel.settings.sourceRoot,
+      enumType.namespace
+    );
+    emitType(sdkContext, rawEnum, sourceFile);
+  }
+
+  for (const unionType of codeModel.unions) {
+    const rawUnion = rawUnionLookup.get(
+      getTypeKey(unionType.name, unionType.namespace)
+    );
+    if (!rawUnion) {
       continue;
     }
 
     const sourceFile = getOrCreateModelsFile(
       project,
       codeModel.settings.sourceRoot,
-      getModelNamespaces(sdkContext, type)
+      unionType.namespace
     );
-    emitType(sdkContext, type, sourceFile);
+    emitType(sdkContext, rawUnion, sourceFile);
   }
 
-  for (const [property] of flattenPropertyModelMap) {
+  for (const [property, baseModel] of flattenPropertyModelMap) {
+    if (!includedModelKeys.has(getRawTypeKey(baseModel, sdkContext))) {
+      continue;
+    }
+
     const sourceFile = getOrCreateModelsFile(
       project,
       codeModel.settings.sourceRoot,
@@ -54,19 +86,23 @@ export function emitModelFiles(
   return cleanupEmptyModelFiles(project, codeModel.settings.sourceRoot);
 }
 
-function isGenerableType(
-  type: SdkType
-): type is SdkArrayType | SdkDictionaryType | SdkNullableType | SdkType {
-  return (
-    type.kind === "model" ||
-    type.kind === "enum" ||
-    type.kind === "union" ||
-    type.kind === "dict" ||
-    type.kind === "array" ||
-    type.kind === "nullable"
+function buildRawTypeLookup<T extends { name: string }>(
+  types: readonly T[],
+  sdkContext: SdkContext
+): Map<string, T> {
+  return new Map(
+    types.map((type) => [getRawTypeKey(type, sdkContext), type] as const)
   );
 }
 
+function getRawTypeKey(type: { name: string }, sdkContext: SdkContext): string {
+  return getTypeKey(type.name, getModelNamespaces(sdkContext, type as any));
+}
+
+function getTypeKey(name: string, namespace: string[]): string {
+  return `${namespace.join("/")}:${name}`;
+}
+
 function getOrCreateModelsFile(
   project: Project,
   sourceRoot: string,