Add per-table emitter configuration for spec-dashboard (#9054)

Some languages like C# require different emitters for management plane
vs data plane scenarios. Currently, `emitterNames` is only configurable
globally in `CoverageFromAzureStorageOptions`, preventing mixed-emitter
table configurations.

## Changes

- Added optional `emitterNames?: string[]` field to `TableDefinition`
interface
- Modified `splitManifestByTables()` to propagate table-specific emitter
names through the pipeline
- Updated `getCoverageSummaries()` to:
  - Collect union of global and table-specific emitters
  - Load all required reports in single batch
- Filter reports per table using table-specific emitters when present,
falling back to global `options.emitterNames` otherwise
- Refactored `loadReports()` to accept emitter names as parameter

## Example

```typescript
const options: CoverageFromAzureStorageOptions = {
  storageAccountName: "account",
  containerName: "coverage",
  manifestContainerName: "manifests",
  emitterNames: ["@typespec/default"],
  tables: [
    {
      name: "Management Plane",
      packageName: "my-package",
      prefixes: ["mgmt_"],
      emitterNames: ["@azure-tools/typespec-csharp-mgmt"]  // Override for mgmt scenarios
    },
    {
      name: "Data Plane", 
      packageName: "my-package",
      prefixes: ["dataplane_"],
      emitterNames: ["@azure-tools/typespec-csharp"]  // Override for data plane
    }
  ]
};
```

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Add ability to specify emitters per table</issue_title>
> <issue_description>In some languages, like C#, we have different
emitters for mgmt vs data plane scenarios. We should be able to specify
the emitterNames in the TableDefinitions in
CoverageFromAzureStorageOptions. If a table has emitter names we use
that, otherwise fall back to global defaults.</issue_description>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>

- Fixes #9053

<!-- START COPILOT CODING AGENT TIPS -->
---

✨ Let Copilot coding agent [set things up for
you](https://github.com/microsoft/typespec/issues/new?title=✨+Set+up+Copilot+instructions&body=Configure%20instructions%20for%20this%20repository%20as%20documented%20in%20%5BBest%20practices%20for%20Copilot%20coding%20agent%20in%20your%20repository%5D%28https://gh.io/copilot-coding-agent-tips%29%2E%0A%0A%3COnboard%20this%20repo%3E&assignees=copilot)
— coding agent works faster and does higher quality work when set up for
your repo.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: JoshLove-msft <[email protected]>
Co-authored-by: jolov <[email protected]>
Co-authored-by: Timothee Guerin <[email protected]>

Author: 3 people

packages/spec-dashboard/src/apis.test.ts

@@ -224,4 +224,66 @@ describe("splitManifestByTables", () => {
     expect(defaultTable!.manifest.scenarios).toHaveLength(1);
     expect(defaultTable!.manifest.scenarios[0].name).toBe("unique_scenario");
   });
+
+  it("should include emitterNames from table definition", () => {
+    const manifest = createManifest("test-package", "Display Name", ["scenario1"]);
+    const tables: TableDefinition[] = [
+      {
+        name: "Test Table",
+        packageName: "test-package",
+        emitterNames: ["@typespec/emitter-1", "@typespec/emitter-2"],
+      },
+    ];
+
+    const result = splitManifestByTables(manifest, tables);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].emitterNames).toEqual(["@typespec/emitter-1", "@typespec/emitter-2"]);
+  });
+
+  it("should return undefined emitterNames when not specified in table definition", () => {
+    const manifest = createManifest("test-package", "Display Name", ["scenario1"]);
+    const tables: TableDefinition[] = [
+      {
+        name: "Test Table",
+        packageName: "test-package",
+      },
+    ];
+
+    const result = splitManifestByTables(manifest, tables);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].emitterNames).toBeUndefined();
+  });
+
+  it("should handle different emitterNames for different tables", () => {
+    const manifest = createManifest("test-package", "Display Name", [
+      "mgmt_scenario1",
+      "dataplane_scenario1",
+    ]);
+    const tables: TableDefinition[] = [
+      {
+        name: "Management Table",
+        packageName: "test-package",
+        prefixes: ["mgmt_"],
+        emitterNames: ["@azure-tools/typespec-csharp-mgmt"],
+      },
+      {
+        name: "Data Plane Table",
+        packageName: "test-package",
+        prefixes: ["dataplane_"],
+        emitterNames: ["@azure-tools/typespec-csharp"],
+      },
+    ];
+
+    const result = splitManifestByTables(manifest, tables);
+
+    expect(result).toHaveLength(2);
+
+    const mgmtTable = result.find((r) => r.tableName === "Management Table");
+    expect(mgmtTable!.emitterNames).toEqual(["@azure-tools/typespec-csharp-mgmt"]);
+
+    const dataPlaneTable = result.find((r) => r.tableName === "Data Plane Table");
+    expect(dataPlaneTable!.emitterNames).toEqual(["@azure-tools/typespec-csharp"]);
+  });
 });

packages/spec-dashboard/src/apis.ts

@@ -14,6 +14,8 @@ export interface TableDefinition {
   packageName: string;
   /** Prefixes to filter the coverage data. Any scenarios starting with this prefix will be included in this table */
   prefixes?: string[];
+  /** Optional emitter names specific to this table. If not provided, falls back to global emitterNames */
+  emitterNames?: string[];
 }
 
 export interface CoverageFromAzureStorageOptions {
@@ -70,7 +72,7 @@ function matchesPrefixes(scenarioName: string, prefixes: string[]): boolean {
 export function splitManifestByTables(
   manifest: ScenarioManifest,
   tableDefinitions: TableDefinition[],
-): Array<{ manifest: ScenarioManifest; tableName: string }> {
+): Array<{ manifest: ScenarioManifest; tableName: string; emitterNames?: string[] }> {
   const packageName = manifest.packageName ?? "";
   const defaultTableName = manifest.displayName || packageName;
 
@@ -79,10 +81,11 @@ export function splitManifestByTables(
 
   if (applicableTables.length === 0) {
     // No table definitions for this manifest, return as-is with a default name
-    return [{ manifest, tableName: defaultTableName }];
+    return [{ manifest, tableName: defaultTableName, emitterNames: undefined }];
   }
 
-  const result: Array<{ manifest: ScenarioManifest; tableName: string }> = [];
+  const result: Array<{ manifest: ScenarioManifest; tableName: string; emitterNames?: string[] }> =
+    [];
   const usedScenarios = new Set<string>();
 
   // Separate tables with prefixes from catch-all tables (no prefixes)
@@ -109,6 +112,7 @@ export function splitManifestByTables(
           scenarios: filteredScenarios,
         },
         tableName: table.name,
+        emitterNames: table.emitterNames,
       });
     }
   }
@@ -129,6 +133,7 @@ export function splitManifestByTables(
           scenarios: remainingScenarios,
         },
         tableName: table.name,
+        emitterNames: table.emitterNames,
       });
     }
   }
@@ -145,6 +150,7 @@ export function splitManifestByTables(
         scenarios: unmatchedScenarios,
       },
       tableName: defaultTableName,
+      emitterNames: undefined,
     });
   }
 
@@ -156,18 +162,14 @@ export async function getCoverageSummaries(
 ): Promise<CoverageSummary[]> {
   const coverageClient = getCoverageClient(options);
   const manifestClient = getManifestClient(options);
-  const [manifests, generatorReports] = await Promise.all([
-    manifestClient.manifest.get(),
-    loadReports(coverageClient, options),
-  ]);
 
-  const reports = Object.values(generatorReports)[0] as Record<
-    string,
-    ResolvedCoverageReport | undefined
-  >;
-
-  // Split manifests into tables based on configuration
-  const allManifests: Array<{ manifest: ScenarioManifest; tableName: string }> = [];
+  // First, split manifests to determine which emitters we need
+  const manifests = await manifestClient.manifest.get();
+  const allManifests: Array<{
+    manifest: ScenarioManifest;
+    tableName: string;
+    emitterNames?: string[];
+  }> = [];
 
   for (const manifest of manifests) {
     if (options.tables && options.tables.length > 0) {
@@ -179,14 +181,42 @@ export async function getCoverageSummaries(
       allManifests.push({
         manifest,
         tableName: manifest.displayName || manifest.packageName || "",
+        emitterNames: undefined,
       });
     }
   }
 
-  return allManifests.map(({ manifest, tableName }) => {
+  // Collect all unique emitter names needed
+  const allEmitterNames = new Set<string>(options.emitterNames);
+  for (const { emitterNames } of allManifests) {
+    if (emitterNames) {
+      emitterNames.forEach((name) => allEmitterNames.add(name));
+    }
+  }
+
+  // Load reports for all needed emitters
+  const generatorReports = await loadReports(coverageClient, options, Array.from(allEmitterNames));
+
+  const reports = Object.values(generatorReports)[0] as Record<
+    string,
+    ResolvedCoverageReport | undefined
+  >;
+
+  return allManifests.map(({ manifest, tableName, emitterNames }) => {
+    // Use table-specific emitters if provided, otherwise use global emitters
+    const effectiveEmitters = emitterNames ?? options.emitterNames;
+
+    // Filter reports to only include the emitters for this table
+    const filteredReports: Record<string, ResolvedCoverageReport | undefined> = {};
+    for (const emitterName of effectiveEmitters) {
+      if (reports[emitterName]) {
+        filteredReports[emitterName] = reports[emitterName];
+      }
+    }
+
     return {
       manifest,
-      generatorReports: processReports(reports, manifest),
+      generatorReports: processReports(filteredReports, manifest),
       tableName,
     };
   });
@@ -230,14 +260,15 @@ function getSuiteReportForManifest(
 async function loadReports(
   coverageClient: SpecCoverageClient,
   options: CoverageFromAzureStorageOptions,
+  emitterNames: string[],
 ): Promise<{
   [mode: string]: Record<string, ResolvedCoverageReport | undefined>;
 }> {
   const results = await Promise.all(
     (options.modes ?? ["standard"]).map(
       async (mode): Promise<[string, Record<string, ResolvedCoverageReport | undefined>]> => {
         const items = await Promise.all(
-          options.emitterNames.map(
+          emitterNames.map(
             async (emitterName): Promise<[string, ResolvedCoverageReport | undefined]> => {
               try {
                 const report = await coverageClient.coverage.getLatestCoverageFor(