@arcote.tech/arc-cli 0.3.0 → 0.3.1

package/dist/index.js

@@ -11202,7 +11202,7 @@ import { dirname as dirname2 } from "path";
 
 // src/utils/build.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join2 } from "path";
 
 // src/utils/config.ts
@@ -16541,27 +16541,17 @@ function getContextsFromConfig(config, configDir) {
 }
 function generateBaseTypes(config, configDir) {
   const { clients } = config;
-  const arcDir = join(configDir, ".arc");
-  if (!existsSync(arcDir)) {
-    mkdirSync(arcDir, { recursive: true });
-  }
-  let typesDefs = `declare global {
-`;
+  let typesDefs = "";
   clients.forEach((client) => {
     const normalizedClient = normalizeClientName(client);
-    typesDefs += `  const ${normalizedClient}: boolean;
+    typesDefs += `declare const ${normalizedClient}: boolean;
 `;
-    typesDefs += `  const NOT_ON_${normalizedClient}: boolean;
+    typesDefs += `declare const NOT_ON_${normalizedClient}: boolean;
 `;
-    typesDefs += `  const ONLY_${normalizedClient}: boolean;
+    typesDefs += `declare const ONLY_${normalizedClient}: boolean;
 `;
   });
-  typesDefs += `}
-
-export {};
-`;
-  writeFileSync(join(arcDir, "types.ts"), typesDefs);
-  writeFileSync(join(configDir, "arc.types.ts"), typesDefs);
+  writeFileSync(join(configDir, "arc.d.ts"), typesDefs);
 }
 function generateClientTypes(config, configDir, client) {
   const { clients } = config;
@@ -16570,23 +16560,18 @@ function generateClientTypes(config, configDir, client) {
   if (!existsSync(clientTypesDir)) {
     mkdirSync(clientTypesDir, { recursive: true });
   }
-  let typesDefs = `declare global {
-`;
+  let typesDefs = "";
   clients.forEach((c) => {
     const normalizedC = normalizeClientName(c);
     const isCurrentClient = normalizeClientName(client) === normalizedC;
-    typesDefs += `  const ${normalizedC}: ${isCurrentClient ? "true" : "false"};
+    typesDefs += `declare const ${normalizedC}: ${isCurrentClient ? "true" : "false"};
 `;
-    typesDefs += `  const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};
+    typesDefs += `declare const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};
 `;
-    typesDefs += `  const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};
+    typesDefs += `declare const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};
 `;
   });
-  typesDefs += `}
-
-export {};
-`;
-  const typesPath = join(clientTypesDir, `${normalizeClientName(client).toLowerCase()}.ts`);
+  const typesPath = join(clientTypesDir, `${normalizeClientName(client).toLowerCase()}.d.ts`);
   writeFileSync(typesPath, typesDefs);
   return typesPath;
 }
@@ -16657,7 +16642,7 @@ async function buildContextBundle(configPath, config, context, client, watch = f
   const externals = getExternals(config, configDir, client);
   const externalArgs = externals.map((dep) => `--external=${dep}`).join(" ");
   const buildTarget = client === "browser" ? "browser" : "bun";
-  const outDirPath = join2(configDir, config.outDir, context.name, client.toLowerCase());
+  const outDirPath = join2(configDir, config.outDir, client.toLowerCase(), context.name);
   const command = `bun build ${context.fullPath} --target=${buildTarget} --outdir=${outDirPath} ${defineArgs} ${externalArgs}${watch ? " --watch" : ""}`;
   return new Promise((resolve, reject) => {
     const proc2 = spawn(command, { shell: true, cwd: configDir });
@@ -16670,27 +16655,29 @@ async function buildContextBundle(configPath, config, context, client, watch = f
       errorOutput += data.toString();
     });
     proc2.on("close", (code) => {
-      if (code !== 0 && !watch) {
+      if (code !== 0 && !watch)
         reject(new Error(`Build failed: ${errorOutput || output}`));
-      } else if (!watch) {
+      else if (!watch)
         resolve();
-      }
     });
   });
 }
 async function buildContextDeclarations(configPath, config, context, client) {
   const configDir = dirname(configPath);
   generateClientTypes(config, configDir, client);
-  const outDir = join2(configDir, config.outDir, context.name, client.toLowerCase());
-  const tsgoResult = await runTsgo(context.fullPath, outDir, configDir);
-  if (tsgoResult !== null) {
-    return tsgoResult;
-  }
-  return runTsc(context.fullPath, outDir, configDir);
+  const outDir = join2(configDir, config.outDir, client.toLowerCase());
+  const arcTypesPath = join2(configDir, "arc.d.ts");
+  const files = existsSync2(arcTypesPath) ? [context.fullPath, arcTypesPath] : [context.fullPath];
+  let result = await runTsgo(files, outDir, configDir);
+  if (result === null) {
+    result = await runTsc(files, outDir, configDir);
+  }
+  return result;
 }
-async function runTsgo(entryFile, outDir, cwd) {
+async function runTsgo(files, outDir, cwd) {
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsgo ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --ignoreConfig`;
   return new Promise((resolve) => {
-    const command = `npx tsgo --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --ignoreConfig "${entryFile}"`;
     const proc2 = spawn(command, { shell: true, cwd });
     let output = "";
     let errorOutput = "";
@@ -16700,26 +16687,21 @@ async function runTsgo(entryFile, outDir, cwd) {
     proc2.stderr.on("data", (data) => {
       errorOutput += data.toString();
     });
-    proc2.on("error", () => {
-      resolve(null);
-    });
+    proc2.on("error", () => resolve(null));
     proc2.on("close", (code) => {
       if (errorOutput.includes("not found") || errorOutput.includes("ENOENT") || errorOutput.includes("Cannot find")) {
         resolve(null);
         return;
       }
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors
-      });
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
-async function runTsc(entryFile, outDir, cwd) {
+async function runTsc(files, outDir, cwd) {
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsc ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext`;
   return new Promise((resolve) => {
-    const command = `npx tsc --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext "${entryFile}"`;
     const proc2 = spawn(command, { shell: true, cwd });
     let output = "";
     let errorOutput = "";
@@ -16730,27 +16712,21 @@ async function runTsc(entryFile, outDir, cwd) {
       errorOutput += data.toString();
     });
     proc2.on("close", (code) => {
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors
-      });
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
 function parseTypeScriptErrors(output, cwd) {
   const errors = [];
-  const lines = output.split(`
-`);
-  for (const line of lines) {
+  for (const line of output.split(`
+`)) {
     const match2 = line.match(/^(.+?)(?:\((\d+),(\d+)\)|:(\d+):(\d+))\s*[-:]\s*error\s+TS\d+:\s*(.+)$/);
     if (match2) {
       const file = match2[1].replace(cwd + "/", "");
       const lineNum = match2[2] || match2[4];
       const col = match2[3] || match2[5];
-      const message = match2[6];
-      errors.push(`${file}:${lineNum}:${col} - ${message}`);
+      errors.push(`${file}:${lineNum}:${col} - ${match2[6]}`);
     } else if (line.includes("error TS")) {
       errors.push(line.trim());
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",

package/src/utils/build.ts

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import type { ArcConfig, ContextInfo } from "./config";
 import { generateClientTypes } from "./config";
@@ -23,9 +23,6 @@ export interface BuildTask {
   watch: boolean;
 }
 
-/**
- * Read package.json and extract peer dependencies
- */
 function getPeerDependencies(configDir: string): string[] {
   try {
     const packageJsonPath = join(configDir, "package.json");
@@ -36,9 +33,6 @@ function getPeerDependencies(configDir: string): string[] {
   }
 }
 
-/**
- * Get external dependencies for a specific client
- */
 function getExternals(
   config: ArcConfig,
   configDir: string,
@@ -46,27 +40,20 @@ function getExternals(
 ): string[] {
   const peerDeps = getPeerDependencies(configDir);
   const externals = new Set<string>(peerDeps);
-
   if (config.externals?.common) {
     config.externals.common.forEach((ext) => externals.add(ext));
   }
-
   const clientExternals =
     config.externals?.[client as keyof typeof config.externals];
   if (Array.isArray(clientExternals)) {
     clientExternals.forEach((ext) => externals.add(ext));
   }
-
   return Array.from(externals);
 }
 
-/**
- * Build a single context for a specific client
- */
 export async function buildContext(task: BuildTask): Promise<BuildResult> {
   const startTime = Date.now();
   const { configPath, config, context, client, watch } = task;
-
   const result: BuildResult = {
     success: false,
     context: context.name,
@@ -77,11 +64,8 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
   };
 
   try {
-    // Build the JavaScript bundle
     await buildContextBundle(configPath, config, context, client, watch);
     result.jsBuilt = true;
-
-    // Build declarations
     if (!watch) {
       const declResult = await buildContextDeclarations(
         configPath,
@@ -92,7 +76,6 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
       result.declarationsBuilt = declResult.success;
       result.declarationErrors = declResult.errors;
     }
-
     result.success = result.jsBuilt;
     result.duration = Date.now() - startTime;
     return result;
@@ -103,9 +86,6 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
   }
 }
 
-/**
- * Build JavaScript bundle for a context
- */
 export async function buildContextBundle(
   configPath: string,
   config: ArcConfig,
@@ -114,54 +94,42 @@ export async function buildContextBundle(
   watch: boolean = false,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   const defineValues: Record<string, string> = {};
-
   for (const c of config.clients) {
     const normalizedC = c.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     defineValues[normalizedC] = c === client ? "true" : "false";
     defineValues[`NOT_ON_${normalizedC}`] = c === client ? "false" : "true";
     defineValues[`ONLY_${normalizedC}`] = c === client ? "true" : "false";
   }
-
   const defineArgs = Object.entries(defineValues)
     .map(([key, value]) => `--define="${key}=${value}"`)
     .join(" ");
-
   const externals = getExternals(config, configDir, client);
   const externalArgs = externals.map((dep) => `--external=${dep}`).join(" ");
-
   const buildTarget = client === "browser" ? "browser" : "bun";
-
+  // JS output: dist/{client}/{context}/ (matches TypeScript declaration output)
   const outDirPath = join(
     configDir,
     config.outDir,
-    context.name,
     client.toLowerCase(),
+    context.name,
   );
-
   const command = `bun build ${context.fullPath} --target=${buildTarget} --outdir=${outDirPath} ${defineArgs} ${externalArgs}${watch ? " --watch" : ""}`;
 
   return new Promise((resolve, reject) => {
     const proc = spawn(command, { shell: true, cwd: configDir });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("close", (code) => {
-      if (code !== 0 && !watch) {
+    proc.on("close", (code: number) => {
+      if (code !== 0 && !watch)
         reject(new Error(`Build failed: ${errorOutput || output}`));
-      } else if (!watch) {
-        resolve();
-      }
+      else if (!watch) resolve();
     });
   });
 }
@@ -172,8 +140,8 @@ interface DeclarationResult {
 }
 
 /**
- * Build declarations for a context using tsgo (TypeScript Go)
- * Falls back to regular tsc if tsgo is not available
+ * Build declarations.
+ * Output: dist/{client}/{context}/ (matches JS output and TypeScript's natural output)
  */
 export async function buildContextDeclarations(
   configPath: string,
@@ -182,61 +150,45 @@ export async function buildContextDeclarations(
   client: string,
 ): Promise<DeclarationResult> {
   const configDir = dirname(configPath);
-
-  // Generate client types
   generateClientTypes(config, configDir, client);
 
-  const outDir = join(
-    configDir,
-    config.outDir,
-    context.name,
-    client.toLowerCase(),
-  );
+  // Output to dist/{client}/ - TypeScript will add {context}/ based on source structure
+  const outDir = join(configDir, config.outDir, client.toLowerCase());
 
-  // Try tsgo first, fall back to tsc
-  const tsgoResult = await runTsgo(context.fullPath, outDir, configDir);
-  if (tsgoResult !== null) {
-    return tsgoResult;
-  }
+  // Include arc.d.ts for global constants
+  const arcTypesPath = join(configDir, "arc.d.ts");
+  const files = existsSync(arcTypesPath)
+    ? [context.fullPath, arcTypesPath]
+    : [context.fullPath];
 
-  // Fallback to tsc
-  return runTsc(context.fullPath, outDir, configDir);
+  // Try tsgo, fallback to tsc - use configDir as rootDir
+  let result = await runTsgo(files, outDir, configDir);
+  if (result === null) {
+    result = await runTsc(files, outDir, configDir);
+  }
+  return result;
 }
 
-/**
- * Run tsgo CLI for declaration generation
- * Returns null if tsgo is not available
- */
 async function runTsgo(
-  entryFile: string,
+  files: string[],
   outDir: string,
   cwd: string,
 ): Promise<DeclarationResult | null> {
-  return new Promise((resolve) => {
-    // Use npx to run tsgo from @typescript/native-preview
-    // --ignoreConfig to skip tsconfig.json when files are specified on command line
-    const command = `npx tsgo --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --ignoreConfig "${entryFile}"`;
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsgo ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --ignoreConfig`;
 
+  return new Promise((resolve) => {
     const proc = spawn(command, { shell: true, cwd });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("error", () => {
-      // tsgo not available
-      resolve(null);
-    });
-
-    proc.on("close", (code) => {
-      // Check if tsgo was not found
+    proc.on("error", () => resolve(null));
+    proc.on("close", (code: number) => {
       if (
         errorOutput.includes("not found") ||
         errorOutput.includes("ENOENT") ||
@@ -245,64 +197,40 @@ async function runTsgo(
         resolve(null);
         return;
       }
-
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors,
-      });
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
 
-/**
- * Run tsc CLI for declaration generation (fallback)
- */
 async function runTsc(
-  entryFile: string,
+  files: string[],
   outDir: string,
   cwd: string,
 ): Promise<DeclarationResult> {
-  return new Promise((resolve) => {
-    const command = `npx tsc --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext "${entryFile}"`;
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsc ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext`;
 
+  return new Promise((resolve) => {
     const proc = spawn(command, { shell: true, cwd });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("close", (code) => {
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors,
-      });
+    proc.on("close", (code: number) => {
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
 
-/**
- * Parse TypeScript CLI error output into structured errors
- */
 function parseTypeScriptErrors(output: string, cwd: string): string[] {
   const errors: string[] = [];
-  const lines = output.split("\n");
-
-  for (const line of lines) {
-    // Match TypeScript error format: file(line,col): error TS1234: message
-    // or: file:line:col - error TS1234: message
+  for (const line of output.split("\n")) {
     const match = line.match(
       /^(.+?)(?:\((\d+),(\d+)\)|:(\d+):(\d+))\s*[-:]\s*error\s+TS\d+:\s*(.+)$/,
     );
@@ -310,33 +238,28 @@ function parseTypeScriptErrors(output: string, cwd: string): string[] {
       const file = match[1].replace(cwd + "/", "");
       const lineNum = match[2] || match[4];
       const col = match[3] || match[5];
-      const message = match[6];
-      errors.push(`${file}:${lineNum}:${col} - ${message}`);
+      errors.push(`${file}:${lineNum}:${col} - ${match[6]}`);
     } else if (line.includes("error TS")) {
-      // Catch any other error format
       errors.push(line.trim());
     }
   }
-
   return errors;
 }
 
-// Legacy functions for backward compatibility
+// Legacy
 export async function buildClient(
   configPath: string,
   config: ArcConfig,
   client: string,
-  watch: boolean = false,
+  watch = false,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   if (config.file) {
     const context: ContextInfo = {
       name: "main",
       entryFile: config.file,
       fullPath: join(configDir, config.file),
     };
-
     await buildContextBundle(configPath, config, context, client, watch);
   }
 }
@@ -347,14 +270,12 @@ export async function buildDeclarations(
   client: string,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   if (config.file) {
     const context: ContextInfo = {
       name: "main",
       entryFile: config.file,
       fullPath: join(configDir, config.file),
     };
-
     await buildContextDeclarations(configPath, config, context, client);
   }
 }

package/src/utils/config.ts

@@ -113,40 +113,29 @@ export function getContextsFromConfig(
 
 /**
  * Generate base types file for TypeScript intellisense
- * This creates a file with all constants defined as boolean type
+ * This creates a .d.ts file with all constants defined as boolean type
  */
 export function generateBaseTypes(config: ArcConfig, configDir: string): void {
   const { clients } = config;
 
-  // Create .arc directory if it doesn't exist
-  const arcDir = join(configDir, ".arc");
-  if (!existsSync(arcDir)) {
-    mkdirSync(arcDir, { recursive: true });
-  }
-
-  // Generate types.ts file with boolean declarations for IDE support
-  let typesDefs = `declare global {\n`;
+  // Generate ambient declarations (no export {} so they're truly global)
+  let typesDefs = "";
 
   clients.forEach((client) => {
     const normalizedClient = normalizeClientName(client);
 
-    typesDefs += `  const ${normalizedClient}: boolean;\n`;
-    typesDefs += `  const NOT_ON_${normalizedClient}: boolean;\n`;
-    typesDefs += `  const ONLY_${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const ${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const NOT_ON_${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const ONLY_${normalizedClient}: boolean;\n`;
   });
 
-  typesDefs += `}\n\nexport {};\n`;
-
-  writeFileSync(join(arcDir, "types.ts"), typesDefs);
-
-  // Also generate arc.types.ts in root for backward compatibility
-  // Only generate at root level - contexts should reference the root file
-  writeFileSync(join(configDir, "arc.types.ts"), typesDefs);
+  // Write as .d.ts file in the config directory for proper TypeScript pickup
+  writeFileSync(join(configDir, "arc.d.ts"), typesDefs);
 }
 
 /**
  * Generate client-specific types file for a build
- * This creates a file with concrete true/false values based on the current client
+ * This creates a .d.ts file with concrete true/false values based on the current client
  */
 export function generateClientTypes(
   config: ArcConfig,
@@ -154,33 +143,31 @@ export function generateClientTypes(
   client: string,
 ): string {
   const { clients } = config;
-  const arcDir = join(configDir, ".arc");
 
-  // Create client-specific types directory
+  // Create .arc/client-types directory
+  const arcDir = join(configDir, ".arc");
   const clientTypesDir = join(arcDir, "client-types");
   if (!existsSync(clientTypesDir)) {
     mkdirSync(clientTypesDir, { recursive: true });
   }
 
-  // Generate client-specific types file
-  let typesDefs = `declare global {\n`;
+  // Generate client-specific ambient declarations
+  let typesDefs = "";
 
   clients.forEach((c) => {
     const normalizedC = normalizeClientName(c);
     const isCurrentClient = normalizeClientName(client) === normalizedC;
 
     // Set concrete values based on the current client
-    typesDefs += `  const ${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
-    typesDefs += `  const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};\n`;
-    typesDefs += `  const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
+    typesDefs += `declare const ${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
+    typesDefs += `declare const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};\n`;
+    typesDefs += `declare const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
   });
 
-  typesDefs += `}\n\nexport {};\n`;
-
-  // Write to a client-specific file
+  // Write as .d.ts file
   const typesPath = join(
     clientTypesDir,
-    `${normalizeClientName(client).toLowerCase()}.ts`,
+    `${normalizeClientName(client).toLowerCase()}.d.ts`,
   );
   writeFileSync(typesPath, typesDefs);