adorn-api 1.0.22 → 1.0.23

package/dist/cli.js

@@ -306,7 +306,7 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
 import ts7 from "typescript";
@@ -1612,7 +1612,221 @@ function resolveAndCollectObjectProps(schema, components) {
 }
 
 // src/compiler/schema/queryBuilderAnalyzer.ts
+import ts10 from "typescript";
+
+// src/compiler/schema/serviceCallAnalyzer.ts
 import ts9 from "typescript";
+var ServiceCallAnalyzer = class {
+  checker;
+  program;
+  cache = /* @__PURE__ */ new Map();
+  analyzedMethods = /* @__PURE__ */ new Set();
+  constructor(checker, program) {
+    this.checker = checker;
+    this.program = program;
+  }
+  /**
+   * Analyzes a controller method for query builder patterns, following service calls
+   */
+  analyzeControllerMethod(methodDeclaration, options = {}) {
+    const cacheKey = this.getMethodCacheKey(methodDeclaration);
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey) ?? null;
+    }
+    const maxDepth = options.maxDepth ?? 3;
+    const schema = this.analyzeMethodWithServiceCalls(methodDeclaration, 0, maxDepth, options);
+    this.cache.set(cacheKey, schema);
+    return schema;
+  }
+  /**
+   * Recursively analyzes method with service call traversal
+   */
+  analyzeMethodWithServiceCalls(methodDeclaration, currentDepth, maxDepth, options) {
+    if (currentDepth >= maxDepth) {
+      return null;
+    }
+    const methodKey = this.getMethodCacheKey(methodDeclaration);
+    if (this.analyzedMethods.has(methodKey)) {
+      return null;
+    }
+    this.analyzedMethods.add(methodKey);
+    const directSchema = analyzeQueryBuilderForSchema(methodDeclaration, this.checker);
+    if (directSchema) {
+      return directSchema;
+    }
+    const serviceCalls = this.findServiceCalls(methodDeclaration);
+    for (const serviceCall of serviceCalls) {
+      const serviceSchema = this.analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options);
+      if (serviceSchema) {
+        return serviceSchema;
+      }
+    }
+    return null;
+  }
+  /**
+   * Analyzes a service method for query builder patterns
+   */
+  analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options) {
+    const directSchema = analyzeQueryBuilderForSchema(serviceCall.methodDeclaration, this.checker);
+    if (directSchema) {
+      return directSchema;
+    }
+    if (options.analyzeHelpers) {
+      return this.analyzeMethodWithServiceCalls(
+        serviceCall.methodDeclaration,
+        currentDepth + 1,
+        maxDepth,
+        options
+      );
+    }
+    return null;
+  }
+  /**
+   * Finds service calls in a method body
+   */
+  findServiceCalls(methodDeclaration) {
+    const serviceCalls = [];
+    const body = methodDeclaration.body;
+    if (!body) {
+      return serviceCalls;
+    }
+    const visitor = (node) => {
+      if (ts9.isCallExpression(node)) {
+        const serviceCall = this.resolveServiceCall(node);
+        if (serviceCall) {
+          serviceCalls.push(serviceCall);
+        }
+      }
+      ts9.forEachChild(node, visitor);
+    };
+    ts9.forEachChild(body, visitor);
+    return serviceCalls;
+  }
+  /**
+   * Resolves a call expression to a service method
+   */
+  resolveServiceCall(callExpression) {
+    if (ts9.isPropertyAccessExpression(callExpression.expression)) {
+      const propAccess = callExpression.expression;
+      const methodName = propAccess.name.text;
+      const objectType = this.checker.getTypeAtLocation(propAccess.expression);
+      const objectSymbol = objectType.getSymbol();
+      if (objectSymbol) {
+        const classDeclaration = this.findClassDeclaration(objectSymbol);
+        if (classDeclaration) {
+          const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
+          if (methodDeclaration) {
+            return {
+              serviceName: classDeclaration.name?.text || "Unknown",
+              methodName,
+              filePath: classDeclaration.getSourceFile().fileName,
+              classDeclaration,
+              methodDeclaration
+            };
+          }
+        }
+      }
+    }
+    if (ts9.isPropertyAccessExpression(callExpression.expression)) {
+      const propAccess = callExpression.expression;
+      const methodName = propAccess.name.text;
+      if (ts9.isIdentifier(propAccess.expression)) {
+        const className = propAccess.expression.text;
+        const classSymbol = this.checker.getSymbolAtLocation(propAccess.expression);
+        if (classSymbol) {
+          const classDeclaration = this.findClassDeclaration(classSymbol);
+          if (classDeclaration && classDeclaration.name?.text === className) {
+            const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
+            if (methodDeclaration) {
+              return {
+                serviceName: className,
+                methodName,
+                filePath: classDeclaration.getSourceFile().fileName,
+                classDeclaration,
+                methodDeclaration
+              };
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds class declaration from a symbol
+   */
+  findClassDeclaration(symbol) {
+    const declarations = symbol.getDeclarations();
+    if (!declarations) return null;
+    for (const declaration of declarations) {
+      if (ts9.isClassDeclaration(declaration)) {
+        return declaration;
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds method declaration in a class
+   */
+  findMethodDeclaration(classDeclaration, methodName) {
+    for (const member of classDeclaration.members) {
+      if (ts9.isMethodDeclaration(member) && member.name) {
+        if (ts9.isIdentifier(member.name) && member.name.text === methodName) {
+          return member;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Generates cache key for a method
+   */
+  getMethodCacheKey(methodDeclaration) {
+    const sourceFile = methodDeclaration.getSourceFile();
+    const className = this.getClassName(methodDeclaration);
+    const methodName = methodDeclaration.name?.getText() || "unknown";
+    const line = sourceFile.getLineAndCharacterOfPosition(methodDeclaration.getStart()).line;
+    return `${sourceFile.fileName}:${className}:${methodName}:${line}`;
+  }
+  /**
+   * Gets class name from method declaration
+   */
+  getClassName(methodDeclaration) {
+    let node = methodDeclaration;
+    while (node) {
+      if (ts9.isClassDeclaration(node)) {
+        return node.name?.text || "Unknown";
+      }
+      node = node.parent;
+    }
+    return "Unknown";
+  }
+  /**
+   * Clears the analysis cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.analyzedMethods.clear();
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      cached: this.cache.size,
+      analyzed: this.analyzedMethods.size
+    };
+  }
+};
+function analyzeControllerWithServiceCalls(methodDeclaration, checker, program, options = {}) {
+  if (!program) {
+    return null;
+  }
+  const analyzer = new ServiceCallAnalyzer(checker, program);
+  return analyzer.analyzeControllerMethod(methodDeclaration, options);
+}
+
+// src/compiler/schema/queryBuilderAnalyzer.ts
 function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {}) {
   const body = methodDeclaration.body;
   if (!body) {
@@ -1632,8 +1846,18 @@ function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {})
   }
   return parseQueryBuilderChain(callChain, checker, options);
 }
-function analyzeQueryBuilderWithDetails(methodDeclaration, checker, options = {}, operationInfo) {
-  const schema = analyzeQueryBuilderForSchema(methodDeclaration, checker, options);
+function analyzeQueryBuilderWithServiceCalls(methodDeclaration, checker, program, options = {}, operationInfo) {
+  let schema = analyzeQueryBuilderForSchema(methodDeclaration, checker, options);
+  if (!schema && program) {
+    try {
+      schema = analyzeControllerWithServiceCalls(methodDeclaration, checker, program, {
+        maxDepth: options.maxDepth,
+        analyzeHelpers: options.analyzeHelpers
+      });
+    } catch (error) {
+      console.warn("Service call analysis failed:", error);
+    }
+  }
   return {
     detected: schema !== null,
     schema,
@@ -1648,12 +1872,12 @@ function analyzeWithVariableTracking(body, checker, options) {
   let isPaged = false;
   let hasReturn = false;
   for (const statement of body.statements) {
-    if (ts9.isReturnStatement(statement)) {
+    if (ts10.isReturnStatement(statement)) {
       hasReturn = true;
       const returnExpr = statement.expression;
-      if (returnExpr && ts9.isCallExpression(returnExpr)) {
+      if (returnExpr && ts10.isCallExpression(returnExpr)) {
         const callExpr = returnExpr;
-        if (ts9.isIdentifier(callExpr.expression) && queryBuilderVar) {
+        if (ts10.isIdentifier(callExpr.expression) && queryBuilderVar) {
           const varName = callExpr.expression.text;
           if (varName === queryBuilderVar) {
             const methodName = callExpr.expression.text;
@@ -1662,9 +1886,9 @@ function analyzeWithVariableTracking(body, checker, options) {
             }
           }
         }
-        if (ts9.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
+        if (ts10.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
           const propAccess = callExpr.expression;
-          if (ts9.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
+          if (ts10.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
             const methodName = propAccess.name.text;
             if (methodName === "executePaged") {
               isPaged = true;
@@ -1674,13 +1898,13 @@ function analyzeWithVariableTracking(body, checker, options) {
       }
       continue;
     }
-    if (!ts9.isExpressionStatement(statement)) {
-      if (ts9.isVariableStatement(statement)) {
+    if (!ts10.isExpressionStatement(statement)) {
+      if (ts10.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
-          if (!ts9.isIdentifier(declaration.name)) continue;
+          if (!ts10.isIdentifier(declaration.name)) continue;
           const varName = declaration.name.text;
           const initializer = declaration.initializer;
-          if (!initializer || !ts9.isCallExpression(initializer)) continue;
+          if (!initializer || !ts10.isCallExpression(initializer)) continue;
           const opInfo = extractChainedOperation(initializer);
           if (opInfo && (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom")) {
             queryBuilderVar = varName;
@@ -1693,13 +1917,13 @@ function analyzeWithVariableTracking(body, checker, options) {
       continue;
     }
     const expr = statement.expression;
-    if (ts9.isBinaryExpression(expr) && expr.operatorToken.kind === ts9.SyntaxKind.EqualsToken) {
-      if (!ts9.isIdentifier(expr.left)) {
+    if (ts10.isBinaryExpression(expr) && expr.operatorToken.kind === ts10.SyntaxKind.EqualsToken) {
+      if (!ts10.isIdentifier(expr.left)) {
         continue;
       }
       const varName = expr.left.text;
       const rightSide = expr.right;
-      if (ts9.isCallExpression(rightSide)) {
+      if (ts10.isCallExpression(rightSide)) {
         const opInfo = extractChainedOperation(rightSide);
         if (opInfo) {
           if (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom") {
@@ -1737,14 +1961,14 @@ function analyzeWithVariableTracking(body, checker, options) {
   };
 }
 function extractChainedOperation(callExpr) {
-  if (ts9.isIdentifier(callExpr.expression)) {
+  if (ts10.isIdentifier(callExpr.expression)) {
     const methodName2 = callExpr.expression.text;
     if (methodName2 === "selectFromEntity" || methodName2 === "selectFrom") {
       const entityArg = callExpr.arguments[0];
       let entityName = null;
-      if (ts9.isIdentifier(entityArg)) {
+      if (ts10.isIdentifier(entityArg)) {
         entityName = entityArg.text;
-      } else if (ts9.isPropertyAccessExpression(entityArg)) {
+      } else if (ts10.isPropertyAccessExpression(entityArg)) {
         entityName = entityArg.name.text;
       }
       return {
@@ -1755,7 +1979,7 @@ function extractChainedOperation(callExpr) {
       };
     }
   }
-  if (!ts9.isPropertyAccessExpression(callExpr.expression)) {
+  if (!ts10.isPropertyAccessExpression(callExpr.expression)) {
     return null;
   }
   const propAccess = callExpr.expression;
@@ -1763,7 +1987,7 @@ function extractChainedOperation(callExpr) {
   if (methodName === "select") {
     const fields = [];
     for (const arg of callExpr.arguments) {
-      if (ts9.isStringLiteral(arg)) {
+      if (ts10.isStringLiteral(arg)) {
         fields.push(arg.text);
       }
     }
@@ -1785,19 +2009,19 @@ function extractChainedOperation(callExpr) {
   return null;
 }
 function parseIncludeObjectLiteral(arg) {
-  if (!ts9.isObjectLiteralExpression(arg)) {
+  if (!ts10.isObjectLiteralExpression(arg)) {
     return null;
   }
   const includes = {};
   for (const prop of arg.properties) {
-    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+    if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
       continue;
     }
     const relationName = prop.name.text;
     const value = prop.initializer;
-    if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+    if (value.kind === ts10.SyntaxKind.TrueKeyword) {
       includes[relationName] = true;
-    } else if (ts9.isObjectLiteralExpression(value)) {
+    } else if (ts10.isObjectLiteralExpression(value)) {
       const nestedSchema = parseNestedInclude(value, 0);
       if (nestedSchema) {
         includes[relationName] = nestedSchema;
@@ -1810,18 +2034,18 @@ function parseNestedInclude(obj, depth) {
   const selectedFields = [];
   const includes = {};
   for (const prop of obj.properties) {
-    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+    if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
       continue;
     }
     const propName = prop.name.text;
     const value = prop.initializer;
-    if (propName === "select" && ts9.isArrayLiteralExpression(value)) {
+    if (propName === "select" && ts10.isArrayLiteralExpression(value)) {
       for (const element of value.elements) {
-        if (ts9.isStringLiteral(element)) {
+        if (ts10.isStringLiteral(element)) {
           selectedFields.push(element.text);
         }
       }
-    } else if (propName === "include" && ts9.isObjectLiteralExpression(value)) {
+    } else if (propName === "include" && ts10.isObjectLiteralExpression(value)) {
       const nestedIncludes = parseIncludeObjectLiteral(value);
       if (nestedIncludes) {
         for (const [relName, relSchema] of Object.entries(nestedIncludes)) {
@@ -1838,10 +2062,10 @@ function parseNestedInclude(obj, depth) {
   };
 }
 function getMethodName(expression) {
-  if (ts9.isIdentifier(expression)) {
+  if (ts10.isIdentifier(expression)) {
     return expression.text;
   }
-  if (ts9.isPropertyAccessExpression(expression)) {
+  if (ts10.isPropertyAccessExpression(expression)) {
     return expression.name.text;
   }
   return null;
@@ -1849,7 +2073,7 @@ function getMethodName(expression) {
 function findReturnStatement(body) {
   let returnStatement = null;
   for (const statement of body.statements) {
-    if (ts9.isReturnStatement(statement)) {
+    if (ts10.isReturnStatement(statement)) {
       if (returnStatement !== null) {
         return null;
       }
@@ -1862,20 +2086,20 @@ function analyzeReturnExpression(expression) {
   if (!expression) {
     return null;
   }
-  if (ts9.isCallExpression(expression)) {
+  if (ts10.isCallExpression(expression)) {
     return buildCallChain(expression, null);
   }
   return null;
 }
 function buildCallChain(node, parent) {
-  if (ts9.isCallExpression(node)) {
+  if (ts10.isCallExpression(node)) {
     const callNode = {
       expression: node.expression,
       methodName: getMethodName(node.expression),
       arguments: node.arguments,
       parent
     };
-    if (ts9.isPropertyAccessExpression(node.expression)) {
+    if (ts10.isPropertyAccessExpression(node.expression)) {
       return buildCallChain(node.expression.expression, callNode);
     }
     return callNode;
@@ -1902,7 +2126,7 @@ function parseQueryBuilderChain(chain, checker, options) {
     const methodName = currentNode.methodName;
     if (methodName === "select") {
       for (const arg of currentNode.arguments) {
-        if (ts9.isStringLiteral(arg)) {
+        if (ts10.isStringLiteral(arg)) {
           selectedFields.add(arg.text);
         }
       }
@@ -1937,10 +2161,10 @@ function extractEntityName(callNode, checker) {
     return null;
   }
   const entityArg = callNode.arguments[0];
-  if (ts9.isIdentifier(entityArg)) {
+  if (ts10.isIdentifier(entityArg)) {
     return entityArg.text;
   }
-  if (ts9.isPropertyAccessExpression(entityArg)) {
+  if (ts10.isPropertyAccessExpression(entityArg)) {
     return entityArg.name.text;
   }
   return null;
@@ -1949,16 +2173,16 @@ function parseIncludeArgument(arg, includes, checker, options, depth) {
   if (!arg) {
     return;
   }
-  if (ts9.isObjectLiteralExpression(arg)) {
+  if (ts10.isObjectLiteralExpression(arg)) {
     for (const prop of arg.properties) {
-      if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+      if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
         continue;
       }
       const relationName = prop.name.text;
       const value = prop.initializer;
-      if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+      if (value.kind === ts10.SyntaxKind.TrueKeyword) {
         includes[relationName] = true;
-      } else if (ts9.isObjectLiteralExpression(value)) {
+      } else if (ts10.isObjectLiteralExpression(value)) {
         const maxDepth = options.maxDepth ?? 5;
         if (depth < maxDepth) {
           const nestedSchema = parseNestedInclude(value, depth + 1);
@@ -2018,9 +2242,11 @@ function generateOpenAPI(controllers, checker, options = {}) {
         paths[fullPath] = {};
       }
       const method = operation.httpMethod.toLowerCase();
-      const analysisResult = analyzeQueryBuilderWithDetails(
+      const analysisResult = analyzeQueryBuilderWithServiceCalls(
         operation.methodDeclaration,
         checker,
+        null,
+        // TODO: Pass program when available
         {},
         {
           methodName: operation.operationId,
@@ -2323,12 +2549,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts11.isClassDeclaration(classDecl)) return schema;
+  if (!ts12.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts11.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts11.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts12.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts12.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -2341,7 +2567,7 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
 }
 
 // src/compiler/manifest/emit.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
@@ -2363,7 +2589,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts12.version
+      typescript: ts13.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -2848,7 +3074,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts13 from "typescript";
+import ts14 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -2881,7 +3107,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts13.version
+      typescript: ts14.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -3043,6 +3269,8 @@ var Spinner = class {
   current = 0;
   total = 0;
   customStatus;
+  frameIndex = 0;
+  lastLineLength = 0;
   constructor(message = "") {
     this.message = message;
   }
@@ -3050,9 +3278,8 @@ var Spinner = class {
    * Start the spinner.
    */
   start() {
-    let frameIndex = 0;
     this.interval = setInterval(() => {
-      const frame = this.frames[frameIndex];
+      const frame = this.frames[this.frameIndex];
       let output;
       if (this.customStatus) {
         output = `\r${frame} ${this.customStatus}`;
@@ -3061,11 +3288,12 @@ var Spinner = class {
       } else {
         output = `\r${frame} ${this.message}`;
       }
+      this.lastLineLength = output.length - 1;
       process.stdout.write(output);
       if (process.stdout.writable) {
         process.stdout.write("");
       }
-      frameIndex = (frameIndex + 1) % this.frames.length;
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
     }, 80);
   }
   /**
@@ -3080,8 +3308,12 @@ var Spinner = class {
    */
   setStatus(status) {
     this.customStatus = status;
-    const frame = this.frames[this.current];
-    process.stdout.write(`\r${frame} ${status}`);
+    const frame = this.frames[this.frameIndex];
+    const output = `\r${frame} ${status}`;
+    const clearLength = Math.max(this.lastLineLength, output.length - 1);
+    process.stdout.write("\r" + " ".repeat(clearLength) + "\r");
+    this.lastLineLength = output.length - 1;
+    process.stdout.write(output);
     if (process.stdout.writable) {
       process.stdout.write("");
     }
@@ -3100,7 +3332,7 @@ var Spinner = class {
       clearInterval(this.interval);
       this.interval = void 0;
     }
-    process.stdout.write("\r" + " ".repeat(60) + "\r");
+    process.stdout.write("\r" + " ".repeat(this.lastLineLength) + "\r");
     if (completedMessage) {
       process.stdout.write(completedMessage + "\n");
     }
@@ -3634,7 +3866,7 @@ function getEdgesByRelation(graph, relation) {
 }
 
 // src/compiler/graph/builder.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // src/compiler/graph/schemaGraph.ts
 var SchemaGraph = class {
@@ -3886,7 +4118,7 @@ var SchemaGraph = class {
 };
 
 // src/cli.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 import process2 from "process";
 var ADORN_VERSION = (() => {
   const tryReadPackageJson = (filePath) => {
@@ -3964,7 +4196,7 @@ function sanitizeForJson(obj) {
   return result;
 }
 function buildControllerGraph(controllers) {
-  const graph = createGraph(ts15.version);
+  const graph = createGraph(ts16.version);
   const nodeMap = /* @__PURE__ */ new Map();
   for (const ctrl of controllers) {
     const nodeId = `Controller:${ctrl.className}`;
@@ -4076,7 +4308,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts15.version
+      typescriptVersion: ts16.version
     });
     if (!stale.stale) {
       progress.completePhase("staleness-check");