@azure-tools/typespec-ts 0.56.0-dev.1 → 0.56.0-dev.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.56.0-dev.1",
-  "description": "An experimental TypeSpec emitter for TypeScript",
+  "version": "0.56.0-dev.10",
+  "description": "A TypeSpec emitter for TypeScript",
   "main": "dist/src/index.js",
   "type": "module",
   "exports": {
@@ -42,9 +42,7 @@
     "@typespec/xml": "^0.83.0 || >=0.84.0-dev <0.84.0",
     "@typespec/ts-http-runtime": "0.3.6",
     "cross-env": "^10.1.0",
-    "mkdirp": "^3.0.1",
-    "npm-run-all": "~4.1.5",
-    "prettier": "^3.8.1",
+    "concurrently": "^10.0.0",
     "vitest": "^4.1.3",
     "vite": "^8.0.8",
     "@vitest/coverage-v8": "^4.1.3",
@@ -62,7 +60,6 @@
   },
   "dependencies": {
     "fast-xml-parser": "^5.7.0",
-    "handlebars": "^4.7.7",
     "prettier": "^3.8.1",
     "ts-morph": "^23.0.0",
     "tslib": "^2.3.1"
@@ -89,28 +86,21 @@
     "clean": "rimraf ./dist ./typespec-output",
     "build": "tsc -p .",
     "test": "npm run test-next && npm run unit-test && npm run integration-test-ci",
-    "test:azure": "npm run test-next && npm run copy:typespec && npm run integration-test-ci:azure-modular",
-    "lint": "eslint . --ext .ts --max-warnings=0",
-    "lint:fix": "eslint . --fix --ext .ts",
+    "lint": "oxlint . --deny-warnings",
+    "lint:fix": "oxlint . --fix",
     "check:tree": "node ./test/commands/check-clean-tree.ts",
-    "test:ts:e2e": "npm run copy:typespec && npm run integration-test-ci:azure-modular",
-    "integration-test-ci": "npm-run-all copy:typespec integration-test-ci:azure-modular",
-    "integration-test-ci:sequential": "npm-run-all --serial copy:typespec integration-test-ci:azure-modular",
-    "integration-test-ci:azure-modular": "npm-run-all --silent -p start-test-server:azure-modular --race generate-and-run:azure-modular",
-    "start-test-server": "mkdirp -p coverage && npx tsp-spector serve ./node_modules/@typespec/http-specs/specs  --coverageFile ./coverage/spector-coverage-typescript.json",
-    "start-test-server:azure-modular": "mkdirp -p coverage && npx tsp-spector serve ./node_modules/@azure-tools/azure-http-specs/specs ./node_modules/@typespec/http-specs/specs --port 3002  --coverageFile ./coverage/spector-coverage-typescript-modular-azure.json",
+    "integration-test-ci": "npm run copy:typespec && npm run spector-test",
+    "spector-test": "concurrently --kill-others --success first \"npm:start-test-server\" \"npm:generate-and-run\"",
+    "start-test-server": "node ./test/commands/start-test-server.js",
     "copy:typespec": "node ./test/commands/copy-typespec.ts",
-    "generate-and-run:azure-modular": "npm run generate-tsp-only:azure-modular:client && npm-run-all -p integration-test:alone:azure-modular generate-tsp-only:azure-modular:declarations && npm run stop-test-server -- -p 3002",
-    "generate-tsp-only": "npm run generate-tsp-only:azure-modular",
-    "generate-tsp-only:azure-modular": "node ./test/commands/gen-spector.js",
-    "generate-tsp-only:azure-modular:client": "node ./test/commands/gen-spector.js --phase=client",
-    "generate-tsp-only:azure-modular:declarations": "node ./test/commands/gen-spector.js --phase=declarations",
+    "generate-and-run": "npm run generate-tsp-only:client && concurrently --kill-others-on-fail \"npm:integration-test:alone\" \"npm:generate-tsp-only:declarations\" && npm run stop-test-server -- -p 3002",
+    "generate-tsp-only": "node ./test/commands/gen-spector.js",
+    "generate-tsp-only:client": "node ./test/commands/gen-spector.js --phase=client",
+    "generate-tsp-only:declarations": "node ./test/commands/gen-spector.js --phase=declarations",
     "regen-test-baselines": "npm run generate-tsp-only",
-    "integration-test:alone": "npm run integration-test:alone:azure-modular",
-    "integration-test:alone:azure-modular": "vitest run --project integration-azure-modular",
+    "integration-test:alone": "vitest run --project integration-azure-modular",
     "stop-test-server": "npx tsp-spector server stop",
-    "unit-test": "npm run unit-test:modular",
-    "unit-test:modular": "cross-env NODE_OPTIONS=--max-old-space-size=1024 vitest run --project unit-modular",
+    "unit-test": "cross-env NODE_OPTIONS=--max-old-space-size=1024 vitest run --project unit-modular",
     "gen:scenario-suites": "node ./test/commands/gen-scenario-suites.ts",
     "regen-docs": "npm run build && tspd doc . --enable-experimental --output-dir ../../website/src/content/docs/docs/emitters/clients/typespec-ts/reference --skip-js"
   }

package/src/context-manager.ts

@@ -4,7 +4,7 @@ import { Project, SourceFile } from "ts-morph";
 import { ExternalDependencies } from "./framework/dependency.js";
 import { Binder } from "./framework/hooks/binder.js";
 import { SdkTypeContext } from "./framework/hooks/sdk-types.js";
-import { RlcMetaTree } from "./meta-tree.js";
+import { ClientTypeMetaTree } from "./meta-tree.js";
 
 /**
  * Contexts Object Guidelines
@@ -20,7 +20,7 @@ import { RlcMetaTree } from "./meta-tree.js";
  * Remember, adding too many contexts can lead to complex dependencies and harder-to-maintain code. Always evaluate if the context is truly necessary or if there are better alternatives such as localized state management or passing props for simpler scenarios.
  */
 type Contexts = {
-  rlcMetaTree: RlcMetaTree; // Context for RLC types metadata.
+  clientTypeMetaTree: ClientTypeMetaTree; // Context for client type metadata.
   outputProject: Project; // The TS-Morph root project context for code generation.
   symbolMap: Map<string, SourceFile>; // Mapping of symbols to their corresponding source files.
   sdkTypes: SdkTypeContext;

package/src/framework/declaration.ts

@@ -8,12 +8,14 @@ import {
   InterfaceDeclaration,
   InterfaceDeclarationStructure,
   SourceFile,
+  StatementStructures,
   StructureKind,
   TypeAliasDeclaration,
   TypeAliasDeclarationStructure,
 } from "ts-morph";
 import { useBinder } from "./hooks/binder.js";
 import { refkey as getRefKey } from "./refkey.js";
+import { enqueueStatement } from "./source-file-batch.js";
 export type DeclarationStructures =
   | ClassDeclarationStructure
   | EnumDeclarationStructure
@@ -80,25 +82,11 @@ export function addDeclaration(
   // Update the declaration name to be unique
   const trackedDeclaration = { ...declaration, name: trackedDeclarationName };
 
-  switch (trackedDeclaration.kind) {
-    case StructureKind.Class:
-      sourceFile.addClass(trackedDeclaration);
-      break;
-    case StructureKind.Enum:
-      sourceFile.addEnum(trackedDeclaration);
-      break;
-    case StructureKind.Function:
-      sourceFile.addFunction(trackedDeclaration);
-      break;
-    case StructureKind.Interface:
-      sourceFile.addInterface(trackedDeclaration);
-      break;
-    case StructureKind.TypeAlias:
-      if (trackedDeclaration.type) {
-        sourceFile.addTypeAlias(trackedDeclaration);
-      }
-      break;
-    default:
-      throw new Error(`Unsupported declaration kind ${(trackedDeclaration as any).kind}`);
+  // Skip empty type aliases (they have no body to emit). Done before
+  // dispatching so behaviour is identical whether batching or not.
+  if (trackedDeclaration.kind === StructureKind.TypeAlias && !trackedDeclaration.type) {
+    return;
   }
+
+  enqueueStatement(sourceFile, trackedDeclaration as StatementStructures);
 }

package/src/framework/hooks/sdk-types.ts

@@ -14,8 +14,8 @@ import { reportDiagnostic } from "../../lib.js";
 import { visitPackageTypes } from "../../modular/emit-models.js";
 import { getAllAncestors, getAllProperties } from "../../modular/helpers/operation-helpers.js";
 import { normalizeModelPropertyName } from "../../modular/type-expressions/get-type-expression.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { NameType, normalizeName } from "../../utils/name-utils.js";
 
 export const emitQueue: Set<SdkType> = new Set<SdkType>();
 export const flattenPropertyModelMap: Map<SdkModelPropertyType, SdkModelType> = new Map<

package/src/framework/source-file-batch.ts

@@ -0,0 +1,140 @@
+import {
+  ExportDeclarationStructure,
+  SourceFile,
+  StatementStructures,
+  StructureKind,
+} from "ts-morph";
+
+/**
+ * Generic per-source-file batch for ts-morph `add*` mutations.
+ *
+ * Each individual `sourceFile.addInterface/addFunction/addExportDeclaration/...`
+ * call re-parses the entire source file in ts-morph. Calling them in a loop
+ * therefore grows as O(N × file_size). This module collects structures while
+ * a batch is open and, on flush, issues a single `addStatements` call per file,
+ * collapsing N re-parses into 1.
+ *
+ * The batch is reference-counted so nested begin/flush pairs compose safely.
+ * Statements flush in insertion order and produce byte-identical output.
+ */
+
+let batchDepth = 0;
+const pendingByFile = new Map<SourceFile, StatementStructures[]>();
+
+/**
+ * Opens a batching scope. Subsequent `enqueueStatement` calls queue rather
+ * than mutate the AST until the matching `flushSourceFileBatch` is called.
+ */
+export function beginSourceFileBatch(): void {
+  batchDepth++;
+}
+
+/**
+ * Closes the most recent batching scope. When the outermost scope closes,
+ * all pending structures are written to their source files in bulk.
+ */
+export function flushSourceFileBatch(): void {
+  if (batchDepth === 0) {
+    return;
+  }
+  batchDepth--;
+  if (batchDepth > 0) {
+    return;
+  }
+  try {
+    for (const [sourceFile, statements] of pendingByFile) {
+      if (statements.length === 0) {
+        continue;
+      }
+      sourceFile.addStatements(statements);
+    }
+  } finally {
+    pendingByFile.clear();
+  }
+}
+
+/**
+ * Queues a statement structure for bulk-add on flush, or writes it
+ * immediately when no batch is open.
+ * @param sourceFile - Target source file.
+ * @param structure - The statement structure to add.
+ */
+export function enqueueStatement(sourceFile: SourceFile, structure: StatementStructures): void {
+  if (batchDepth > 0) {
+    let pending = pendingByFile.get(sourceFile);
+    if (!pending) {
+      pending = [];
+      pendingByFile.set(sourceFile, pending);
+    }
+    pending.push(structure);
+    return;
+  }
+  sourceFile.addStatements([structure]);
+}
+
+/**
+ * Returns the set of names exported from `sourceFile` considering both the
+ * declarations already present in its AST and any export declarations queued
+ * by the current batch. Use this in place of reading `getExportDeclarations`
+ * directly when callers dedup against existing exports inside a batch.
+ * @param sourceFile - The file to inspect.
+ */
+export function getEffectiveExportedNames(sourceFile: SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const decl of sourceFile.getExportDeclarations()) {
+    for (const named of decl.getNamedExports()) {
+      names.add(named.getAliasNode()?.getText() ?? named.getName());
+    }
+  }
+  const pending = pendingByFile.get(sourceFile);
+  if (pending) {
+    for (const structure of pending) {
+      if (structure.kind !== StructureKind.ExportDeclaration) {
+        continue;
+      }
+      collectNamedExportNames(structure.namedExports, names);
+    }
+  }
+  return names;
+}
+
+/**
+ * Returns the set of named exports queued in the current batch for
+ * `sourceFile`. Use this to union with any AST-based view of exports
+ * (e.g. `getExportedDeclarations`) when deduplicating against still-pending
+ * writes inside a batch.
+ * @param sourceFile - The file to inspect.
+ */
+export function getQueuedExportNames(sourceFile: SourceFile): Set<string> {
+  const names = new Set<string>();
+  const pending = pendingByFile.get(sourceFile);
+  if (!pending) {
+    return names;
+  }
+  for (const structure of pending) {
+    if (structure.kind !== StructureKind.ExportDeclaration) {
+      continue;
+    }
+    collectNamedExportNames(structure.namedExports, names);
+  }
+  return names;
+}
+
+function collectNamedExportNames(
+  named: ExportDeclarationStructure["namedExports"],
+  into: Set<string>,
+): void {
+  if (!named || typeof named === "function") {
+    // WriterFunction form is opaque to us; callers can't dedup by name.
+    return;
+  }
+  for (const item of named) {
+    if (typeof item === "string") {
+      into.add(item);
+    } else if (typeof item === "function") {
+      continue;
+    } else if (item) {
+      into.add(item.alias ?? item.name);
+    }
+  }
+}

package/src/index.ts

@@ -31,37 +31,6 @@ import {
   UrlTemplateHelpers,
   XmlHelpers,
 } from "./modular/static-helpers-metadata.js";
-import {
-  RLCModel,
-  RLCOptions,
-  buildApiExtractorConfig,
-  buildChangelogFile,
-  buildEsLintConfig,
-  buildLicenseFile,
-  buildPackageFile,
-  buildReadmeFile,
-  buildRecordedClientFile,
-  buildSampleEnvFile,
-  buildSampleTest,
-  buildSnippets,
-  buildTestBrowserTsConfig,
-  buildTestNodeTsConfig,
-  buildTsConfig,
-  buildTsLintConfig,
-  buildTsSampleConfig,
-  buildTsSnippetsConfig,
-  buildTsSrcBrowserConfig,
-  buildTsSrcCjsConfig,
-  buildTsSrcEsmConfig,
-  buildTsSrcReactNativeConfig,
-  buildVitestConfig,
-  buildWarpConfig,
-  getClientName,
-  hasClientNameChanged,
-  hasUnexpectedHelper,
-  updatePackageFile,
-  updateReadmeFile,
-} from "./rlc-common/index.js";
 import { emitContentByBuilder } from "./utils/emit-util.js";
 import { clearDirectory, emptyDir, pathExists } from "./utils/file-system-utils.js";
 import { GenerationDirDetail, SdkContext } from "./utils/interfaces.js";
@@ -76,7 +45,35 @@ import { Project } from "ts-morph";
 import { provideBinder } from "./framework/hooks/binder.js";
 import { provideSdkTypes } from "./framework/hooks/sdk-types.js";
 import { loadStaticHelpers } from "./framework/load-static-helpers.js";
+import { ClientModel, ClientOptions } from "./interfaces.js";
 import { EmitterOptions } from "./lib.js";
+import { buildApiExtractorConfig } from "./metadata/build-api-extractor-config.js";
+import { buildChangelogFile } from "./metadata/build-changelog-file.js";
+import { buildEsLintConfig } from "./metadata/build-es-lint-config.js";
+import { buildLicenseFile } from "./metadata/build-license-file.js";
+import { buildPackageFile, updatePackageFile } from "./metadata/build-package-file.js";
+import {
+  buildReadmeFile,
+  hasClientNameChanged,
+  updateReadmeFile,
+} from "./metadata/build-readme-file.js";
+import { buildSampleEnvFile } from "./metadata/build-sample-env-file.js";
+import { buildTestBrowserTsConfig, buildTestNodeTsConfig } from "./metadata/build-test-config.js";
+import {
+  buildTsConfig,
+  buildTsLintConfig,
+  buildTsSampleConfig,
+  buildTsSnippetsConfig,
+  buildTsSrcBrowserConfig,
+  buildTsSrcCjsConfig,
+  buildTsSrcEsmConfig,
+  buildTsSrcReactNativeConfig,
+} from "./metadata/build-ts-config.js";
+import { buildVitestConfig } from "./metadata/build-vitest-config.js";
+import { buildWarpConfig } from "./metadata/build-warp-config.js";
+import { buildRecordedClientFile } from "./metadata/test/build-recorded-client.js";
+import { buildSampleTest } from "./metadata/test/build-sample-test.js";
+import { buildSnippets } from "./metadata/test/build-snippets.js";
 import { buildClassicalClient } from "./modular/build-classical-client.js";
 import { buildClassicOperationFiles } from "./modular/build-classical-operation-groups.js";
 import { buildClientContext, getClientContextPath } from "./modular/build-client-context.js";
@@ -93,13 +90,9 @@ import { emitTests } from "./modular/emit-tests.js";
 import { getClassicalClientName } from "./modular/helpers/naming-helpers.js";
 import { ModularEmitterOptions } from "./modular/interfaces.js";
 import { packageUsesXmlSerialization } from "./modular/serialization/build-xml-serializer-function.js";
-import { transformRLCModel } from "./transform/transform.js";
-import { transformRLCOptions } from "./transform/transfrom-rlc-options.js";
-import {
-  getClientHierarchyMap,
-  getModularClientOptions,
-  getRLCClients,
-} from "./utils/client-utils.js";
+import { transformClientOptions } from "./transform/transform-client-options.js";
+import { transformClientModel } from "./transform/transform.js";
+import { getClientHierarchyMap, getClientModuleInfo, getClients } from "./utils/client-utils.js";
 import { generateCrossLanguageDefinitionFile } from "./utils/cross-language-def.js";
 
 export * from "./lib.js";
@@ -128,11 +121,9 @@ export async function $onEmit(context: EmitContext) {
 
   // Enrich the dpg context with path detail and common options
   await enrichDpgContext();
-  const rlcOptions = dpgContext.rlcOptions ?? {};
+  const resolvedEmitterOptions = dpgContext.emitterOptions ?? {};
 
-  const needUnexpectedHelper: Map<string, boolean> = new Map<string, boolean>();
-  const serviceNameToRlcModelsMap: Map<string, RLCModel> = new Map<string, RLCModel>();
-  provideContext("rlcMetaTree", new Map());
+  provideContext("clientTypeMetaTree", new Map());
   provideContext("symbolMap", new Map());
   provideContext("outputProject", outputProject);
   provideContext("emitContext", {
@@ -151,13 +142,13 @@ export async function $onEmit(context: EmitContext) {
       ...PlatformTypeHelpers,
       ...CloudSettingHelpers,
       ...XmlHelpers,
-      ...(rlcOptions.generateTest ? CreateRecorderHelpers : {}),
-      ...(rlcOptions.enableStorageCompat ? StorageCompatHelpers : {}),
+      ...(resolvedEmitterOptions.generateTest ? CreateRecorderHelpers : {}),
+      ...(resolvedEmitterOptions.enableStorageCompat ? StorageCompatHelpers : {}),
     },
     {
-      sourcesDir: dpgContext.generationPathDetail?.modularSourcesDir,
+      sourcesDir: dpgContext.generationPathDetail?.sourcesDir,
       rootDir: dpgContext.generationPathDetail?.rootDir,
-      options: rlcOptions,
+      options: resolvedEmitterOptions,
       program,
       host,
       packageRoot: emitterPackageRoot,
@@ -178,20 +169,16 @@ export async function $onEmit(context: EmitContext) {
   });
   provideSdkTypes(dpgContext);
 
-  const rlcCodeModels: RLCModel[] = [];
   let modularEmitterOptions: ModularEmitterOptions;
   // 1. Clear sources folder
   await clearSrcFolder();
-  // 2. Generate RLC code model
-  // TODO: skip this step in modular once modular generator is sufficiently decoupled
-  await buildRLCCodeModels();
-  // 3. Clear samples-dev folder if generateSample is true
+  // 2. Clear samples-dev folder if generateSample is true
   await clearSamplesDevFolder();
 
-  // 4. Generate sources
-  await generateModularSources();
+  // 3. Generate sources
+  await generateSources();
 
-  // 5. Generate metadata and test files
+  // 4. Generate metadata and test files
   function getTypespecTsVersion(context: EmitContext): string | undefined {
     const emitterMetadata = context.program.emitters.find(
       (emitter) => emitter.metadata.name === "@azure-tools/typespec-ts",
@@ -205,7 +192,7 @@ export async function $onEmit(context: EmitContext) {
     const generationPathDetail: GenerationDirDetail = await calculateGenerationDir();
     dpgContext.generationPathDetail = generationPathDetail;
     dpgContext.allServiceNamespaces = listAllServiceNamespaces(dpgContext);
-    const options: RLCOptions = transformRLCOptions(emitterOptions, dpgContext);
+    const options: ClientOptions = transformClientOptions(emitterOptions, dpgContext);
     emitterOptions["generate-sample"] = options.generateSample;
     // clear output folder if needed
     if (options.clearOutputFolder) {
@@ -219,7 +206,7 @@ export async function $onEmit(context: EmitContext) {
     options.generateTest =
       options.generateTest === true ||
       (options.generateTest === undefined && (!hasTestFolder || options.azureArm));
-    dpgContext.rlcOptions = options;
+    dpgContext.emitterOptions = options;
   }
 
   async function calculateGenerationDir(): Promise<GenerationDirDetail> {
@@ -236,18 +223,12 @@ export async function $onEmit(context: EmitContext) {
     return {
       rootDir: projectRoot,
       metadataDir: projectRoot,
-      rlcSourcesDir: sourcesRoot,
-      modularSourcesDir: sourcesRoot,
+      sourcesDir: sourcesRoot,
     };
   }
 
   async function clearSrcFolder() {
-    await emptyDir(
-      host,
-      dpgContext.generationPathDetail?.modularSourcesDir ??
-        dpgContext.generationPathDetail?.rlcSourcesDir ??
-        "",
-    );
+    await emptyDir(host, dpgContext.generationPathDetail?.sourcesDir ?? "");
   }
 
   async function clearSamplesDevFolder() {
@@ -262,32 +243,30 @@ export async function $onEmit(context: EmitContext) {
     }
   }
 
-  async function buildRLCCodeModels() {
-    const clients = getRLCClients(dpgContext);
+  async function buildClientCodeModels(): Promise<ClientModel[]> {
+    const models: ClientModel[] = [];
+    const clients = getClients(dpgContext);
     for (const client of clients) {
-      const rlcModels = await transformRLCModel(client, dpgContext);
-      rlcCodeModels.push(rlcModels);
-      const serviceName = client.services[0]?.name ?? "Unknown";
-      serviceNameToRlcModelsMap.set(serviceName, rlcModels);
-      needUnexpectedHelper.set(getClientName(rlcModels), hasUnexpectedHelper(rlcModels));
+      models.push(await transformClientModel(client, dpgContext));
     }
+    return models;
   }
 
-  async function generateModularSources() {
-    const modularSourcesRoot = dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
+  async function generateSources() {
+    const sourcesRoot = dpgContext.generationPathDetail?.sourcesDir ?? "src";
     const project = useContext("outputProject");
-    modularEmitterOptions = transformModularEmitterOptions(dpgContext, modularSourcesRoot, {
+    modularEmitterOptions = transformModularEmitterOptions(dpgContext, sourcesRoot, {
       casing: "camel",
     });
 
-    emitLoggerFile(modularEmitterOptions, modularSourcesRoot);
+    emitLoggerFile(modularEmitterOptions, sourcesRoot);
 
-    const rootIndexFile = project.createSourceFile(`${modularSourcesRoot}/index.ts`, "", {
+    const rootIndexFile = project.createSourceFile(`${sourcesRoot}/index.ts`, "", {
       overwrite: true,
     });
 
-    emitTypes(dpgContext, { sourceRoot: modularSourcesRoot });
-    emitNonModelResponseTypes(dpgContext, { sourceRoot: modularSourcesRoot });
+    emitTypes(dpgContext, { sourceRoot: sourcesRoot });
+    emitNonModelResponseTypes(dpgContext, { sourceRoot: sourcesRoot });
     buildSubpathIndexFile(modularEmitterOptions, "models", undefined, {
       recursive: true,
     });
@@ -302,7 +281,7 @@ export async function $onEmit(context: EmitContext) {
       buildOperationFiles(dpgContext, subClient, modularEmitterOptions);
       buildClientContext(dpgContext, subClient, modularEmitterOptions);
       buildRestorePoller(dpgContext, subClient, modularEmitterOptions);
-      if (dpgContext.rlcOptions?.hierarchyClient) {
+      if (dpgContext.emitterOptions?.hierarchyClient) {
         buildSubpathIndexFile(modularEmitterOptions, "api", subClient, {
           exportIndex: false,
           recursive: true,
@@ -320,24 +299,24 @@ export async function $onEmit(context: EmitContext) {
         exportIndex: true,
         interfaceOnly: true,
       });
-      const { subfolder } = getModularClientOptions(subClient);
+      const { subfolder } = getClientModuleInfo(subClient);
       // Generate index file for clients with subfolders (multi-client scenarios and nested clients)
       if (subfolder) {
         buildSubClientIndexFile(dpgContext, subClient, modularEmitterOptions);
       }
       buildRootIndex(dpgContext, modularEmitterOptions, rootIndexFile, subClient);
     }
-    // Enable modular sample generation when explicitly set to true or MPG
+    // Sample generation is enabled only when the modular generator actually emits
+    // samples. Reset the baseline here, then re-enable it below if any are emitted.
+    dpgContext.emitterOptions!.generateSample = false;
     if (emitterOptions["generate-sample"] === true) {
       const samples = emitSamples(dpgContext);
-      // Refine the rlc sample generation logic
-      // TODO: remember to remove this out when RLC is splitted from Modular
       if (samples.length > 0) {
-        dpgContext.rlcOptions!.generateSample = true;
+        dpgContext.emitterOptions!.generateSample = true;
       }
     }
 
-    binder.resolveAllReferences(modularSourcesRoot, dpgContext.generationPathDetail?.rootDir);
+    binder.resolveAllReferences(sourcesRoot, dpgContext.generationPathDetail?.rootDir);
     if (program.compilerOptions.noEmit || program.hasError()) {
       return;
     }
@@ -382,17 +361,18 @@ export async function $onEmit(context: EmitContext) {
 
   async function generateMetadataAndTest(context: SdkContext) {
     const project = useContext("outputProject");
-    if (rlcCodeModels.length === 0 || !rlcCodeModels[0]) {
+    const clientCodeModels = await buildClientCodeModels();
+    if (clientCodeModels.length === 0 || !clientCodeModels[0]) {
       return;
     }
-    const rlcClient: RLCModel = rlcCodeModels[0];
-    const option = dpgContext.rlcOptions!;
+    const clientModel: ClientModel = clientCodeModels[0];
+    const option = dpgContext.emitterOptions!;
     // When generateMetadata is explicitly false and the sources are generated
     // into a path ending with "generated" (e.g. src/generated), this package
     // has a manual convenience layer. Skip all metadata/test file generation
     // to avoid unexpected modifications to files like package.json, README.md,
     // warp.config.yml, and snippets.spec.ts. metadata.json is still updated.
-    const sourcesDir = dpgContext.generationPathDetail?.modularSourcesDir ?? "";
+    const sourcesDir = dpgContext.generationPathDetail?.sourcesDir ?? "";
     const hasManualConvenienceLayer = getBaseFileName(sourcesDir) === "generated";
     // Generate metadata
     const existingPackageFilePath = joinPaths(
@@ -426,7 +406,7 @@ export async function $onEmit(context: EmitContext) {
 
     //TODO Need consider multi-client cases
     for (const subClient of dpgContext.sdkPackage.clients) {
-      rlcClient.libraryName = subClient.name;
+      clientModel.libraryName = subClient.name;
     }
 
     if (shouldGenerateMetadata) {
@@ -496,7 +476,7 @@ export async function $onEmit(context: EmitContext) {
       await emitContentByBuilder(
         program,
         commonBuilders,
-        rlcClient,
+        clientModel,
         dpgContext.generationPathDetail?.metadataDir,
       );
 
@@ -525,8 +505,8 @@ export async function $onEmit(context: EmitContext) {
         }),
       };
 
-      // Always update package.json (adds #platform/* imports) and, for modular
-      // packages, exports, clientContextPaths and LRO deps.
+      // Always update package.json (adds #platform/* imports) along with
+      // exports, clientContextPaths and LRO deps.
       {
         // Read package.json content via host and pass parsed object
         const pkgSourceFile = await host.readFile(existingPackageFilePath);
@@ -536,30 +516,30 @@ export async function $onEmit(context: EmitContext) {
         } catch {
           packageInfo = {};
         }
-        updateBuilders.push((model: RLCModel) =>
+        updateBuilders.push((model: ClientModel) =>
           updatePackageFile(model, packageInfo, modularPackageInfo),
         );
       }
 
       // Update warp.config.yml for Azure monorepo packages
-      updateBuilders.push((model: RLCModel) => buildWarpConfig(model, modularPackageInfo));
+      updateBuilders.push((model: ClientModel) => buildWarpConfig(model, modularPackageInfo));
 
       // If the client name changed, regenerate the README and snippets completely;
       // otherwise update only the API reference link in-place.
       if (hasReadmeFile) {
         const readmeSourceFile = await host.readFile(existingReadmeFilePath);
         const existingReadmeContent = readmeSourceFile.text;
-        const clientNameChanged = hasClientNameChanged(rlcClient, existingReadmeContent);
+        const clientNameChanged = hasClientNameChanged(clientModel, existingReadmeContent);
         updateBuilders.push(
           clientNameChanged
             ? buildReadmeFile
-            : (model: RLCModel) => updateReadmeFile(model, existingReadmeContent),
+            : (model: ClientModel) => updateReadmeFile(model, existingReadmeContent),
         );
 
         // Regenerate snippets.spec.ts only when the client name changed
         if (clientNameChanged) {
           for (const subClient of dpgContext.sdkPackage.clients) {
-            updateBuilders.push((model: RLCModel) =>
+            updateBuilders.push((model: ClientModel) =>
               buildSnippets(model, getClassicalClientName(subClient)),
             );
           }
@@ -570,14 +550,14 @@ export async function $onEmit(context: EmitContext) {
       await emitContentByBuilder(
         program,
         updateBuilders,
-        rlcClient,
+        clientModel,
         dpgContext.generationPathDetail?.metadataDir,
       );
     }
     await emitContentByBuilder(
       program,
       buildMetadataJson,
-      rlcClient,
+      clientModel,
       dpgContext.generationPathDetail?.metadataDir,
     );
 
@@ -586,7 +566,7 @@ export async function $onEmit(context: EmitContext) {
       await emitContentByBuilder(
         program,
         [buildRecordedClientFile, buildSampleTest],
-        rlcClient,
+        clientModel,
         dpgContext.generationPathDetail?.metadataDir,
       );
     }