chore(typescript): optimize fixImportsForEsm with single in-memory Volume processing

generators/typescript/express/cli/src/ExpressGeneratorCli.ts

@@ -96,7 +96,6 @@ export class ExpressGeneratorCli extends AbstractGeneratorCli<ExpressCustomConfi
         const typescriptProject = await expressGenerator.generate();
         const persistedTypescriptProject = await typescriptProject.persist();
         await expressGenerator.copyCoreUtilities({
-            pathToSrc: persistedTypescriptProject.getSrcDirectory(),
             pathToRoot: persistedTypescriptProject.getRootDirectory()
         });
 

generators/typescript/express/generator/src/ExpressGenerator.ts

@@ -315,17 +315,8 @@ export class ExpressGenerator {
         });
     }
 
-    public async copyCoreUtilities({
-        pathToSrc,
-        pathToRoot
-    }: {
-        pathToSrc: AbsoluteFilePath;
-        pathToRoot: AbsoluteFilePath;
-    }): Promise<void> {
-        await this.coreUtilitiesManager.copyCoreUtilities({
-            pathToSrc,
-            pathToRoot
-        });
+    public async copyCoreUtilities({ pathToRoot }: { pathToRoot: AbsoluteFilePath }): Promise<void> {
+        await this.coreUtilitiesManager.copyCoreUtilities({ pathToRoot });
     }
 
     private getTypesToGenerate(): Record<FernIr.TypeId, FernIr.TypeDeclaration> {

generators/typescript/sdk/cli/src/SdkGeneratorCli.ts

@@ -7,10 +7,11 @@ import { FernIr } from "@fern-fern/ir-sdk";
 import { AbstractGeneratorCli } from "@fern-typescript/abstract-generator-cli";
 import {
     convertJestImportsToVitest,
-    fixImportsForEsm,
+    fixImportsInVolume,
+    type MemfsVolume,
     NpmPackage,
     PersistedTypescriptProject,
-    writeTemplateFiles
+    writeTemplateFilesToVolume
 } from "@fern-typescript/commons";
 import { GeneratorContext } from "@fern-typescript/contexts";
 import { SdkGenerator } from "@fern-typescript/sdk-generator";
@@ -257,16 +258,29 @@ export class SdkGeneratorCli extends AbstractGeneratorCli<SdkCustomConfig> {
             }
         });
         const typescriptProject = await sdkGenerator.generate();
-        const persistedTypescriptProject = await typescriptProject.persist();
-        const rootDirectory = persistedTypescriptProject.getRootDirectory();
-        await sdkGenerator.copyCoreUtilities({
-            pathToSrc: persistedTypescriptProject.getSrcDirectory(),
-            pathToRoot: rootDirectory
-        });
-        await sdkGenerator.generatePublicExports({
-            pathToSrc: persistedTypescriptProject.getSrcDirectory()
+        // Single in-memory code path for both legacy and non-legacy exports.
+        // The volumeHook runs AFTER writeSrcToVolume inside persist() but
+        // BEFORE writing to disk. Operations MUST execute in this order:
+        //   1. copyCoreUtilitiesToVolume — populates Volume with core files
+        //      (overwrites ts-morph barrel exports at overlapping paths)
+        //   2. writeTemplateFilesToVolume — renders .template.ts → .ts
+        //      (needs core files from step 1 to exist)
+        //   3. generatePublicExportsToVolume — creates exports.ts re-export chain
+        //      (needs core/*/exports.ts from step 1)
+        //   4. fixImportsInVolume — adds .js extensions to all import specifiers
+        //      (needs all files from steps 1-3; only for non-legacy exports)
+        const templateVariables = this.getTemplateVariables(customConfig);
+        const rawPackagePath = customConfig.packagePath ?? "src";
+        const packagePath = rawPackagePath.replace(/^\//, "").replace(/\/$/, "") || "src";
+        const persistedTypescriptProject = await typescriptProject.persist(async (volume: MemfsVolume) => {
+            await sdkGenerator.copyCoreUtilitiesToVolume(volume);
+            writeTemplateFilesToVolume(volume, templateVariables);
+            sdkGenerator.generatePublicExportsToVolume(volume);
+            if (!customConfig.useLegacyExports) {
+                fixImportsInVolume(volume, packagePath);
+            }
         });
-        await writeTemplateFiles(rootDirectory, this.getTemplateVariables(customConfig));
+        const rootDirectory = persistedTypescriptProject.getRootDirectory();
         await this.writeLicenseFile(config, rootDirectory, generatorContext.logger);
         await this.postProcess(persistedTypescriptProject, customConfig);
 
@@ -325,9 +339,6 @@ export class SdkGeneratorCli extends AbstractGeneratorCli<SdkCustomConfig> {
         _customConfig: SdkCustomConfig
     ): Promise<void> {
         const customConfig = this.customConfigWithOverrides(_customConfig);
-        if (customConfig.useLegacyExports === false) {
-            await fixImportsForEsm(persistedTypescriptProject.getRootDirectory());
-        }
         if (customConfig.testFramework === "vitest") {
             await convertJestImportsToVitest(
                 persistedTypescriptProject.getRootDirectory(),

generators/typescript/sdk/generator/src/SdkGenerator.ts

@@ -16,6 +16,7 @@ import {
     getFullPathForEndpoint,
     getTextOfTsNode,
     ImportsManager,
+    type MemfsVolume,
     NpmPackage,
     PackageId,
     PublicExportsManager,
@@ -782,21 +783,13 @@ export class SdkGenerator {
         return this.intermediateRepresentation.types;
     }
 
-    public async copyCoreUtilities({
-        pathToSrc,
-        pathToRoot
-    }: {
-        pathToSrc: AbsoluteFilePath;
-        pathToRoot: AbsoluteFilePath;
-    }): Promise<void> {
-        await this.coreUtilitiesManager.copyCoreUtilities({ pathToSrc, pathToRoot });
+    public async copyCoreUtilitiesToVolume(volume: MemfsVolume): Promise<void> {
+        await this.coreUtilitiesManager.copyCoreUtilitiesToVolume(volume);
     }
 
-    public async generatePublicExports({ pathToSrc }: { pathToSrc: AbsoluteFilePath }): Promise<void> {
-        await this.publicExportsManager.generatePublicExportsFiles({
-            pathToSrc
-        });
-        this.context.logger.debug("Generated public exports");
+    public generatePublicExportsToVolume(volume: MemfsVolume): void {
+        this.publicExportsManager.generatePublicExportsToVolume(volume, this.relativePackagePath);
+        this.context.logger.debug("Generated public exports to volume");
     }
 
     private generateTypeDeclarations() {

generators/typescript/sdk/versions.yml

@@ -1,4 +1,17 @@
 # yaml-language-server: $schema=../../../fern-versions-yml.schema.json
+- version: 3.59.5
+  changelogEntry:
+    - summary: |
+        Optimize ESM import fixup to process all files in a single memfs Volume
+        before writing to disk. All file generation (source files, core utilities,
+        public exports, and template rendering) now happens in-memory, eliminating
+        the post-persist disk passes for fixImportsForCoreFiles and
+        generatePublicExports entirely.
+        At Stripe scale (5K files), import fixup time drops from ~777ms to ~158ms (80% faster).
+      type: chore
+  createdAt: "2026-03-26"
+  irVersion: 65
+
 - version: 3.59.4
   changelogEntry:
     - summary: |

generators/typescript/utils/commons/src/__test__/writeTemplateFiles.test.ts

@@ -0,0 +1,104 @@
+import { Volume } from "memfs/lib/volume";
+import { beforeEach, describe, expect, it } from "vitest";
+import { writeTemplateFilesToVolume } from "../writeTemplateFiles.js";
+
+describe("writeTemplateFilesToVolume", () => {
+    let volume: InstanceType<typeof Volume>;
+
+    beforeEach(() => {
+        volume = new Volume();
+    });
+
+    it("renders a template file and removes the original", () => {
+        volume.mkdirSync("/src/core/fetcher", { recursive: true });
+        volume.writeFileSync(
+            "/src/core/fetcher/getFetchFn.template.ts",
+            'export async function getFetchFn(): Promise<any> {\n    <% if (it.fetchSupport === "native") { %>return fetch;<% } else { %>return (await import("node-fetch")).default;<% } %>\n}\n'
+        );
+
+        writeTemplateFilesToVolume(volume, { fetchSupport: "native" });
+
+        // Rendered file should exist
+        expect(volume.existsSync("/src/core/fetcher/getFetchFn.ts")).toBe(true);
+        const content = volume.readFileSync("/src/core/fetcher/getFetchFn.ts", "utf-8").toString();
+        expect(content).toContain("return fetch;");
+        expect(content).not.toContain("<%");
+        expect(content).not.toContain("%>");
+
+        // Template file should be removed
+        expect(volume.existsSync("/src/core/fetcher/getFetchFn.template.ts")).toBe(false);
+    });
+
+    it("renders template with different variable values", () => {
+        volume.mkdirSync("/src/core/fetcher", { recursive: true });
+        volume.writeFileSync(
+            "/src/core/fetcher/getFetchFn.template.ts",
+            '<% if (it.fetchSupport === "native") { %>NATIVE<% } else { %>NODE_FETCH<% } %>'
+        );
+
+        writeTemplateFilesToVolume(volume, { fetchSupport: "node-fetch" });
+
+        const content = volume.readFileSync("/src/core/fetcher/getFetchFn.ts", "utf-8").toString();
+        expect(content).toContain("NODE_FETCH");
+        expect(content).not.toContain("NATIVE");
+    });
+
+    it("processes multiple template files", () => {
+        volume.mkdirSync("/src/core/fetcher", { recursive: true });
+        volume.writeFileSync(
+            "/src/core/fetcher/getFetchFn.template.ts",
+            "export const fetch = <%= it.fetchSupport %>;"
+        );
+        volume.writeFileSync(
+            "/src/core/fetcher/getResponseBody.template.ts",
+            "export const stream = <%= it.streamType %>;"
+        );
+
+        writeTemplateFilesToVolume(volume, { fetchSupport: '"native"', streamType: '"web"' });
+
+        expect(volume.existsSync("/src/core/fetcher/getFetchFn.ts")).toBe(true);
+        expect(volume.existsSync("/src/core/fetcher/getResponseBody.ts")).toBe(true);
+        expect(volume.existsSync("/src/core/fetcher/getFetchFn.template.ts")).toBe(false);
+        expect(volume.existsSync("/src/core/fetcher/getResponseBody.template.ts")).toBe(false);
+    });
+
+    it("does nothing when no template files exist", () => {
+        volume.mkdirSync("/src/core/fetcher", { recursive: true });
+        volume.writeFileSync("/src/core/fetcher/Fetcher.ts", "export class Fetcher {}\n");
+
+        writeTemplateFilesToVolume(volume, {});
+
+        // Existing file should be untouched
+        const content = volume.readFileSync("/src/core/fetcher/Fetcher.ts", "utf-8").toString();
+        expect(content).toBe("export class Fetcher {}\n");
+    });
+
+    it("only processes files with .template. in the name", () => {
+        volume.mkdirSync("/src", { recursive: true });
+        volume.writeFileSync("/src/regular.ts", "export const x = 1;\n");
+        volume.writeFileSync("/src/template.ts", "export const y = 2;\n");
+        volume.writeFileSync("/src/myFile.template.ts", "export const z = <%= it.value %>;");
+
+        writeTemplateFilesToVolume(volume, { value: "42" });
+
+        // Only the .template. file should be processed
+        expect(volume.readFileSync("/src/regular.ts", "utf-8").toString()).toBe("export const x = 1;\n");
+        expect(volume.readFileSync("/src/template.ts", "utf-8").toString()).toBe("export const y = 2;\n");
+        expect(volume.existsSync("/src/myFile.ts")).toBe(true);
+        expect(volume.readFileSync("/src/myFile.ts", "utf-8").toString()).toBe("export const z = 42;");
+        expect(volume.existsSync("/src/myFile.template.ts")).toBe(false);
+    });
+
+    it("handles nested directory structures", () => {
+        volume.mkdirSync("/src/core/fetcher/internal", { recursive: true });
+        volume.writeFileSync("/src/core/fetcher/internal/helper.template.ts", "export const x = <%= it.val %>;");
+
+        writeTemplateFilesToVolume(volume, { val: "true" });
+
+        expect(volume.existsSync("/src/core/fetcher/internal/helper.ts")).toBe(true);
+        expect(volume.readFileSync("/src/core/fetcher/internal/helper.ts", "utf-8").toString()).toBe(
+            "export const x = true;"
+        );
+        expect(volume.existsSync("/src/core/fetcher/internal/helper.template.ts")).toBe(false);
+    });
+});