[warp] Migrate core packages to warp with type-compatible browser polyfills (#37442)

## [warp] Migrate core packages to warp with type-compatible browser
polyfills

### Root tsconfig changes
- `tsconfig.src.esm.json`: Replace `WebWorker` with `DOM` +
`DOM.Iterable` in `lib`
- `tsconfig.src.cjs.json`: Add `DOM` + `DOM.Iterable` to `lib` (was
`ES2023` only)

### `@azure/core-amqp`
- Add `warp.config.yml`, remove `tshy` config and devDependency
- Add `checkNetworkConnection.common.ts` browser polyfill

### `@azure/core-client`
- Add `warp.config.yml`, remove `tshy` config and devDependency
- Add `import type` annotations to `state-cjs.cts` so tsc can type-check
the polyfill content when it is substituted under the `.ts` filename by
warp's polyfill host
- Update `vitest.config.ts` alias to point to compiled
`dist/commonjs/state.js` instead of source `state-cjs.cts` (Vite/Rollup
treats `.cts` as JavaScript and cannot parse TypeScript syntax like
`import type`)

### `@azure/core-rest-pipeline`
- Add `warp.config.yml`, remove `tshy` config and devDependency

### `@azure/core-tracing`
- Add `warp.config.yml`, remove `tshy` config and devDependency
- Add `import type` annotations to `state-cjs.cts` so tsc can type-check
the polyfill content when it is substituted under the `.ts` filename by
warp's polyfill host
- Update `vitest.config.ts` alias to point to compiled
`dist/commonjs/state.js` instead of source `state-cjs.cts` (Vite/Rollup
treats `.cts` as JavaScript and cannot parse TypeScript syntax like
`import type`)

### `@azure/core-xml`
- Add `warp.config.yml`, remove `tshy` config and devDependency
- Add local `tsconfig.src.browser.json` with `trusted-types` in `types`
(needed by `xml-browser.mts`)
- Remove triple-slash reference directives from `xml-browser.mts`

### `@typespec/ts-http-runtime`
- Add `warp.config.yml`, remove `tshy` config and devDependency
- Add/update browser polyfills: `decompressResponsePolicy-browser.mts`,
`proxyPolicy.common.ts`, `concat.common.ts`
- Update API diff reports for browser and react-native targets
- `concat.common.ts`: Export `ConcatSource` type and add
`NodeJS.ReadableStream` to its union. The browser polyfill
(`concat-browser.mts`) re-exports from `concat.common.ts`. When warp
type-checks the browser target, `multipartPolicy.ts` passes
`BodyPart.body` — whose type includes `NodeJS.ReadableStream` — into
`concat()`. So `ConcatSource` must accept that type to satisfy the
type-checker. tshy never caught this mismatch because it did not
type-check browser polyfills against their callers. The added union
member is unreachable at runtime in browser environments — the function
already throws for unsupported source types.

### warp changes
- Discover `.cts` polyfill files (search order: `.mts` → `.cts` → `.ts`)
- Add `polyfillSuffix: "-cjs"` support for CJS-specific polyfills
(tshy's module-local-state pattern)
- Add `platform: "node"` to esbuild CJS transform so it emits `0 &&
(module.exports = {...})` sentinel for Node's `cjs-module-lexer` to
detect named exports in ESM→CJS interop
- Type-check `.cts` polyfill content by substituting it under the
original `.ts` filename via the polyfill host — tsc sees TypeScript, not
a `.cts` extension

### Why vitest configs changed
The `state.ts` files in core-client and core-tracing use tshy's
module-local-state pattern: the ESM entry (`state.ts`) re-exports from
`../commonjs/state.js` so that ESM and CJS share a single state object
(preventing dual-package hazard). During tests, vitest resolves
`../commonjs/state.js` via an alias. Previously the alias pointed to the
source `state-cjs.cts` file, but Vite/Rollup treats `.cts` as JavaScript
and chokes on TypeScript syntax (`import type`). The fix is to alias to
the compiled `dist/commonjs/state.js` instead.

### Why `.cts` files need type annotations
Warp's polyfill host substitutes the `.cts` file's *content* under the
original `.ts` *filename*, so tsc type-checks it as TypeScript. The
original `.cts` files used `any`-typed variables (e.g. `let state:
any`). Adding proper `import type` declarations and explicit type
annotations (e.g. `as Instrumenter | undefined`,
`WeakMap<OperationRequest, OperationRequestInfo>`) ensures the polyfill
content is fully type-checked at build time, catching mismatches between
the CJS and ESM implementations.

---------

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

Author: deyaaeldeen

common/tools/warp/src/compiler.ts

@@ -285,6 +285,13 @@ export async function discoverPolyfills(
           continue;
         }
 
+        // Check .cts polyfill (e.g. state-cjs.cts for CJS module-local-state)
+        const ctsName = `${stem}${suffix}.cts`;
+        if (entries.has(ctsName)) {
+          polyfillMap.set(path.resolve(fileName), path.join(dir, ctsName));
+          continue;
+        }
+
         // Fall back to .ts polyfill
         const tsName = `${stem}${suffix}.ts`;
         if (entries.has(tsName)) {
@@ -609,12 +616,18 @@ async function transpileWithEsbuild(
   const target = tsTargetToEsbuild(options.target);
   const sourcemap = options.sourceMap !== false;
 
+  // platform:"node" makes esbuild annotate CJS output with
+  // `0 && (module.exports = {...})` so that Node's cjs-module-lexer
+  // can statically detect named exports for ESM→CJS interop.
+  const platform: esbuild.Platform | undefined = format === "cjs" ? "node" : undefined;
+
   return Promise.all(
     sources.map(async ({ fileName, content }) => {
       const result = await esbuild.transform(content, {
         loader: "ts",
         format,
         target,
+        platform,
         sourcemap: sourcemap ? "external" : false,
         sourcefile: fileName,
       });
@@ -727,13 +740,13 @@ export async function transpileFiles(
 /**
  * Filter rootNames to exclude polyfill source files.
  * Uses basename-aware matching: a file is a polyfill if its basename
- * (without extension) ends with the suffix and the extension is .mts or .ts.
+ * (without extension) ends with the suffix and the extension is .mts, .cts, or .ts.
  */
 function filterPolyfillRootNames(rootNames: readonly string[], suffix: string): string[] {
   return rootNames.filter((f) => {
     const base = path.basename(f);
     const ext = path.extname(base);
-    if (ext !== ".mts" && ext !== ".ts") return true;
+    if (ext !== ".mts" && ext !== ".cts" && ext !== ".ts") return true;
     const stem = base.slice(0, -ext.length);
     return !stem.endsWith(suffix);
   });
@@ -925,7 +938,7 @@ export async function compileAllTargets(
     );
 
     // Fast path: when type-checking and declarations are both skipped,
-    // use transpileFiles (ts.transpileModule per-file) to bypass program
+    // use transpileFiles (esbuild per-file transpilation) to bypass program
     // creation entirely — ~3-10× faster for format-only re-emit.
     let primaryResult: CompileResult;
     if (!needsTypeCheck && canSkipDeclarations) {

common/tools/warp/test/public/polyfill.spec.ts

@@ -91,6 +91,47 @@ describe("discoverPolyfills", () => {
     expect(map.size).toBe(1);
     expect(map.get(path.join(tmpDir, "src/foo.ts"))).toBe(path.join(tmpDir, "src/foo-browser.mts"));
   });
+
+  it("discovers .cts polyfill files", async () => {
+    await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, "src/state.ts"), "export const state = { x: undefined };");
+    await fs.writeFile(
+      path.join(tmpDir, "src/state-cjs.cts"),
+      "export const state = { x: undefined };",
+    );
+
+    const fileNames = [path.join(tmpDir, "src/state.ts")];
+    const map = await discoverPolyfills(fileNames, "-cjs");
+    expect(map.size).toBe(1);
+    expect(map.get(path.join(tmpDir, "src/state.ts"))).toBe(
+      path.join(tmpDir, "src/state-cjs.cts"),
+    );
+  });
+
+  it("prefers .mts over .cts over .ts polyfill", async () => {
+    await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, "src/foo.ts"), "export const x = 1;");
+    await fs.writeFile(path.join(tmpDir, "src/foo-cjs.mts"), "export const x = 2; // mts");
+    await fs.writeFile(path.join(tmpDir, "src/foo-cjs.cts"), "export const x = 3; // cts");
+    await fs.writeFile(path.join(tmpDir, "src/foo-cjs.ts"), "export const x = 4; // ts");
+
+    const fileNames = [path.join(tmpDir, "src/foo.ts")];
+    const map = await discoverPolyfills(fileNames, "-cjs");
+    expect(map.size).toBe(1);
+    expect(map.get(path.join(tmpDir, "src/foo.ts"))).toBe(path.join(tmpDir, "src/foo-cjs.mts"));
+  });
+
+  it("prefers .cts over .ts polyfill when no .mts exists", async () => {
+    await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, "src/foo.ts"), "export const x = 1;");
+    await fs.writeFile(path.join(tmpDir, "src/foo-cjs.cts"), "export const x = 3; // cts");
+    await fs.writeFile(path.join(tmpDir, "src/foo-cjs.ts"), "export const x = 4; // ts");
+
+    const fileNames = [path.join(tmpDir, "src/foo.ts")];
+    const map = await discoverPolyfills(fileNames, "-cjs");
+    expect(map.size).toBe(1);
+    expect(map.get(path.join(tmpDir, "src/foo.ts"))).toBe(path.join(tmpDir, "src/foo-cjs.cts"));
+  });
 });
 
 describe("polyfill substitution build", () => {
@@ -326,4 +367,200 @@ describe("polyfill substitution build", () => {
     // They must NOT be identical (dedup should not have fired)
     expect(esmIndex).not.toBe(browserIndex);
   });
+
+  it("substitutes .cts polyfill content in CJS target with full type-checking", async () => {
+    // Source files — state.ts defines a typed state object, state-cjs.cts provides
+    // a type-safe CJS version. This mirrors the tshy module-local-state pattern
+    // used in core-tracing and core-client.
+    await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+    await fs.writeFile(
+      path.join(tmpDir, "src/index.ts"),
+      ['import { state } from "./state.js";', "export { state };"].join("\n"),
+    );
+    // Types in a separate file (like interfaces.ts in core-tracing)
+    await fs.writeFile(
+      path.join(tmpDir, "src/types.ts"),
+      "export interface Widget { name: string; }",
+    );
+    await fs.writeFile(
+      path.join(tmpDir, "src/state.ts"),
+      [
+        'import type { Widget } from "./types.js";',
+        "export const state = {",
+        "  current: undefined as Widget | undefined,",
+        "};",
+      ].join("\n"),
+    );
+    // CJS polyfill — has proper TypeScript types for type-checking
+    await fs.writeFile(
+      path.join(tmpDir, "src/state-cjs.cts"),
+      [
+        'import type { Widget } from "./types.js";',
+        "export const state = {",
+        "  current: undefined as Widget | undefined,",
+        "};",
+      ].join("\n"),
+    );
+
+    // tsconfigs
+    const esmTsconfig = {
+      compilerOptions: {
+        outDir: "./dist/esm",
+        rootDir: "./src",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        target: "ES2023",
+        declaration: true,
+        strict: true,
+      },
+      include: ["src/**/*.ts"],
+    };
+    const cjsTsconfig = {
+      compilerOptions: {
+        outDir: "./dist/commonjs",
+        rootDir: "./src",
+        module: "CommonJS",
+        moduleResolution: "Node10",
+        target: "ES2023",
+        declaration: true,
+        strict: true,
+      },
+      include: ["src/**/*.ts"],
+    };
+
+    await fs.writeFile(path.join(tmpDir, "tsconfig.esm.json"), JSON.stringify(esmTsconfig));
+    await fs.writeFile(path.join(tmpDir, "tsconfig.cjs.json"), JSON.stringify(cjsTsconfig));
+
+    // Warp config — ESM compiled normally, CJS uses -cjs polyfill
+    await fs.writeFile(
+      path.join(tmpDir, "warp.config.yml"),
+      stringify({
+        exports: { ".": "./src/index.ts" },
+        targets: [
+          { name: "esm", condition: "import", tsconfig: "./tsconfig.esm.json" },
+          {
+            name: "commonjs",
+            condition: "require",
+            tsconfig: "./tsconfig.cjs.json",
+            polyfillSuffix: "-cjs",
+          },
+        ],
+      }),
+    );
+
+    await fs.writeFile(
+      path.join(tmpDir, "package.json"),
+      `${JSON.stringify({ name: "test-cts-polyfill", version: "1.0.0", type: "module" }, null, 2)}\n`,
+    );
+    await fs.writeFile(path.join(tmpDir, "pnpm-workspace.yaml"), "packages: []");
+
+    const result = await build({ cwd: tmpDir });
+    expect(result.success).toBe(true);
+
+    // ESM state.js should have the compiled version
+    const esmState = await fs.readFile(path.join(tmpDir, "dist/esm/state.js"), "utf-8");
+    expect(esmState).toContain("undefined");
+
+    // CJS state.js should have the polyfill content (from state-cjs.cts)
+    const cjsState = await fs.readFile(path.join(tmpDir, "dist/commonjs/state.js"), "utf-8");
+    expect(cjsState).toMatch(/undefined|void 0/);
+    // CJS should use tsc's CommonJS exports pattern (Node ESM-interop compatible)
+    expect(cjsState).toContain("exports");
+
+    // CJS target should NOT produce state-cjs.cjs (polyfill is filtered)
+    expect(await exists(path.join(tmpDir, "dist/commonjs/state-cjs.cjs"))).toBe(false);
+
+    // CJS .d.ts should have full type info (type-checked from polyfill content)
+    const cjsDts = await fs.readFile(path.join(tmpDir, "dist/commonjs/state.d.ts"), "utf-8");
+    expect(cjsDts).toContain("Widget");
+    expect(cjsDts).toContain("undefined");
+  });
+
+  it("catches type errors in .cts polyfill files", async () => {
+    await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+    // Types in a separate file
+    await fs.writeFile(
+      path.join(tmpDir, "src/types.ts"),
+      "export interface Widget { name: string; }",
+    );
+    await fs.writeFile(
+      path.join(tmpDir, "src/state.ts"),
+      [
+        'import type { Widget } from "./types.js";',
+        "export const state = {",
+        "  current: undefined as Widget | undefined,",
+        "};",
+      ].join("\n"),
+    );
+    // A consumer that assigns to state.current — requires Widget | undefined type
+    await fs.writeFile(
+      path.join(tmpDir, "src/index.ts"),
+      [
+        'import type { Widget } from "./types.js";',
+        'import { state } from "./state.js";',
+        "export function setWidget(w: Widget): void { state.current = w; }",
+        "export { state };",
+      ].join("\n"),
+    );
+    // CJS polyfill with WRONG type — narrower than what setWidget expects
+    await fs.writeFile(
+      path.join(tmpDir, "src/state-cjs.cts"),
+      ["export const state = {", "  current: undefined,", "};"].join("\n"),
+    );
+
+    const esmTsconfig = {
+      compilerOptions: {
+        outDir: "./dist/esm",
+        rootDir: "./src",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        target: "ES2023",
+        declaration: true,
+        strict: true,
+      },
+      include: ["src/**/*.ts"],
+    };
+    const cjsTsconfig = {
+      compilerOptions: {
+        outDir: "./dist/commonjs",
+        rootDir: "./src",
+        module: "CommonJS",
+        moduleResolution: "Node10",
+        target: "ES2023",
+        declaration: true,
+        strict: true,
+      },
+      include: ["src/**/*.ts"],
+    };
+
+    await fs.writeFile(path.join(tmpDir, "tsconfig.esm.json"), JSON.stringify(esmTsconfig));
+    await fs.writeFile(path.join(tmpDir, "tsconfig.cjs.json"), JSON.stringify(cjsTsconfig));
+
+    await fs.writeFile(
+      path.join(tmpDir, "warp.config.yml"),
+      stringify({
+        exports: { ".": "./src/index.ts" },
+        targets: [
+          { name: "esm", condition: "import", tsconfig: "./tsconfig.esm.json" },
+          {
+            name: "commonjs",
+            condition: "require",
+            tsconfig: "./tsconfig.cjs.json",
+            polyfillSuffix: "-cjs",
+          },
+        ],
+      }),
+    );
+
+    await fs.writeFile(
+      path.join(tmpDir, "package.json"),
+      `${JSON.stringify({ name: "test-type-error", version: "1.0.0", type: "module" }, null, 2)}\n`,
+    );
+    await fs.writeFile(path.join(tmpDir, "pnpm-workspace.yaml"), "packages: []");
+
+    const result = await build({ cwd: tmpDir });
+    // Build should fail because the CJS polyfill has narrow type for state.current
+    // (just `undefined`) but index.ts assigns a Widget to it
+    expect(result.success).toBe(false);
+  });
 });

sdk/core/core-amqp/package.json

@@ -96,29 +96,12 @@
     "playwright": "catalog:testing",
     "prettier": "catalog:",
     "rimraf": "catalog:",
-    "tshy": "catalog:",
     "typescript": "catalog:",
     "vitest": "catalog:testing",
     "ws": "^8.17.0"
   },
   "//metadata": {
     "migrationDate": "2023-03-08T18:36:03.000Z"
   },
-  "tshy": {
-    "exports": {
-      "./package.json": "./package.json",
-      ".": "./src/index.ts"
-    },
-    "dialects": [
-      "esm",
-      "commonjs"
-    ],
-    "esmDialects": [
-      "browser",
-      "react-native"
-    ],
-    "selfLink": false,
-    "project": "../../../tsconfig.src.build.json"
-  },
   "module": "./dist/esm/index.js"
 }

sdk/core/core-amqp/src/util/checkNetworkConnection.common.ts

@@ -5,6 +5,6 @@
  * Checks whether a network connection is detected.
  * @internal
  */
-export function checkNetworkConnection(): Promise<boolean> {
+export function checkNetworkConnection(_host: string): Promise<boolean> {
   return Promise.resolve(self.navigator.onLine);
 }

sdk/core/core-amqp/warp.config.yml

@@ -0,0 +1,22 @@
+# warp.config.yml — @azure/core-amqp build configuration
+
+exports:
+  "./package.json": "./package.json"
+  ".": "./src/index.ts"
+
+targets:
+  - name: browser
+    tsconfig: "../../../tsconfig.src.browser.json"
+    polyfillSuffix: "-browser"
+
+  - name: react-native
+    tsconfig: "../../../tsconfig.src.react-native.json"
+    polyfillSuffix: "-react-native"
+
+  - name: esm
+    condition: import
+    tsconfig: "../../../tsconfig.src.esm.json"
+
+  - name: commonjs
+    condition: require
+    tsconfig: "../../../tsconfig.src.cjs.json"

sdk/core/core-client/package.json

@@ -88,28 +88,11 @@
     "playwright": "catalog:testing",
     "prettier": "catalog:",
     "rimraf": "catalog:",
-    "tshy": "catalog:",
     "typescript": "catalog:",
     "vitest": "catalog:testing"
   },
   "//metadata": {
     "migrationDate": "2023-03-08T18:36:03.000Z"
   },
-  "tshy": {
-    "exports": {
-      "./package.json": "./package.json",
-      ".": "./src/index.ts"
-    },
-    "dialects": [
-      "esm",
-      "commonjs"
-    ],
-    "esmDialects": [
-      "browser",
-      "react-native"
-    ],
-    "selfLink": false,
-    "project": "../../../tsconfig.src.build.json"
-  },
   "module": "./dist/esm/index.js"
 }