@fern-api/fern-api-dev 3.27.2 → 3.28.0

package/cli.cjs

@@ -1413817,7 +1413817,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.27.2",
+          version: "3.28.0",
           usingAccessToken: true
         }
       });
@@ -1413916,7 +1413916,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.27.2",
+        version: "3.28.0",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1493982,7 +1493982,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.27.2";
+    return "3.28.0";
   }
   getCliName() {
     if (false) {
@@ -1588481,7 +1588481,7 @@ var import_path35 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version6 = "3.27.2";
+  const version6 = "3.28.0";
   return `cli@${version6}`;
 }
 var DebugLogger = class {
@@ -1604996,7 +1604996,8 @@ function logViolationsGroup({
     if (title5 === "") {
       title5 = violation.relativeFilepath;
     }
-    return violation.message;
+    const severityLabel = getSeverityLabel(violation.severity);
+    return `${severityLabel} ${violation.message}`;
   }).filter((message) => message != null).join("\n");
   context2.logger.log(
     getLogLevelForSeverity(severity),
@@ -1605032,6 +1605033,18 @@ function getLogLevelForSeverity(severity) {
       assertNever(severity);
   }
 }
+function getSeverityLabel(severity) {
+  switch (severity) {
+    case "fatal":
+      return source_default.red("[error]");
+    case "error":
+      return source_default.red("[error]");
+    case "warning":
+      return source_default.yellow("[warning]");
+    default:
+      assertNever(severity);
+  }
+}
 function logViolationsSummary({
   stats,
   context: context2,
@@ -1605079,6 +1605092,39 @@ function getViolationStats(violations) {
 }
 
 // src/commands/validate/validateDocsWorkspaceAndLogIssues.ts
+async function collectDocsWorkspaceViolations({
+  workspace,
+  apiWorkspaces,
+  ossWorkspaces,
+  context: context2,
+  errorOnBrokenLinks,
+  excludeRules
+}) {
+  if (workspace.config.settings?.substituteEnvVars) {
+    workspace.config = replaceEnvVariables(workspace.config, {
+      onError: (e6) => context2.failAndThrow(e6)
+    });
+  }
+  const startTime = performance.now();
+  const violations = await validateDocsWorkspace(
+    workspace,
+    context2,
+    apiWorkspaces,
+    ossWorkspaces,
+    false,
+    excludeRules
+  );
+  const elapsedMillis = performance.now() - startTime;
+  let hasErrors = violations.some((v21) => v21.severity === "fatal" || v21.severity === "error");
+  if (errorOnBrokenLinks) {
+    hasErrors = hasErrors || violations.some((violation) => violation.name === "valid-markdown-links");
+  }
+  return {
+    violations,
+    elapsedMillis,
+    hasErrors
+  };
+}
 async function validateDocsWorkspaceWithoutExiting({
   workspace,
   apiWorkspaces,
@@ -1627884,13 +1627930,33 @@ async function publishDocs({ token, organization, docsWorkspace, domain: domain2
         apiDefinition = await enhanceExamplesWithAI(apiDefinition, aiEnhancerConfig, context2, token, organization, sourceFilePath);
       }
       let dynamicIRsByLanguage;
+      let languagesWithExistingSdkDynamicIr = /* @__PURE__ */ new Set();
       if (useDynamicSnippets) {
-        dynamicIRsByLanguage = await generateLanguageSpecificDynamicIRs({
+        const existingSdkDynamicIrs = await checkAndDownloadExistingSdkDynamicIRs({
+          fdr,
           workspace,
           organization,
           context: context2,
           snippetsConfig
         });
+        if (existingSdkDynamicIrs && Object.keys(existingSdkDynamicIrs).length > 0) {
+          dynamicIRsByLanguage = existingSdkDynamicIrs;
+          languagesWithExistingSdkDynamicIr = new Set(Object.keys(existingSdkDynamicIrs));
+          context2.logger.debug(`Using existing SDK dynamic IRs for: ${Object.keys(existingSdkDynamicIrs).join(", ")}`);
+        }
+        const generatedDynamicIRs = await generateLanguageSpecificDynamicIRs({
+          workspace,
+          organization,
+          context: context2,
+          snippetsConfig,
+          skipLanguages: languagesWithExistingSdkDynamicIr
+        });
+        if (generatedDynamicIRs) {
+          dynamicIRsByLanguage = {
+            ...dynamicIRsByLanguage,
+            ...generatedDynamicIRs
+          };
+        }
       }
       const response = await fdr.api.v1.register.registerApiDefinition({
         orgId: FdrAPI_exports.OrgId(organization),
@@ -1628060,7 +1628126,203 @@ function parseBasePath(domain2) {
     return void 0;
   }
 }
-async function generateLanguageSpecificDynamicIRs({ workspace, organization, context: context2, snippetsConfig }) {
+async function checkAndDownloadExistingSdkDynamicIRs({ fdr, workspace, organization, context: context2, snippetsConfig }) {
+  if (!workspace) {
+    return void 0;
+  }
+  const snippetConfigWithVersions = await buildSnippetConfigurationWithVersions({
+    fdr,
+    workspace,
+    snippetsConfig,
+    context: context2
+  });
+  if (Object.keys(snippetConfigWithVersions).length === 0) {
+    context2.logger.debug(`[SDK Dynamic IR] No snippet configs with versions found, skipping S3 check`);
+    return void 0;
+  }
+  try {
+    const response = await fdr.api.v1.register.checkSdkDynamicIrExists({
+      orgId: FdrAPI_exports.OrgId(organization),
+      snippetConfiguration: snippetConfigWithVersions
+    });
+    if (!response.ok || !response.body) {
+      context2.logger.debug(`[SDK Dynamic IR] API call failed or returned empty body`);
+      return void 0;
+    }
+    const existingDynamicIrs = response.body.existingDynamicIrs;
+    if (Object.keys(existingDynamicIrs).length === 0) {
+      context2.logger.debug("[SDK Dynamic IR] No existing SDK dynamic IRs found in S3");
+      return void 0;
+    }
+    const result = {};
+    for (const [language, sdkDynamicIrDownload] of Object.entries(existingDynamicIrs)) {
+      try {
+        context2.logger.debug(`Downloading existing SDK dynamic IR for ${language}...`);
+        const downloadResponse = await fetch(sdkDynamicIrDownload.downloadUrl);
+        if (downloadResponse.ok) {
+          const dynamicIR = await downloadResponse.json();
+          result[language] = { dynamicIR };
+          context2.logger.debug(`Successfully downloaded SDK dynamic IR for ${language}`);
+        } else {
+          context2.logger.warn(`Failed to download SDK dynamic IR for ${language}: ${downloadResponse.status}`);
+        }
+      } catch (error2) {
+        context2.logger.warn(`Error downloading SDK dynamic IR for ${language}: ${error2}`);
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  } catch (error2) {
+    context2.logger.debug(`Error checking for existing SDK dynamic IRs: ${error2}`);
+    return void 0;
+  }
+}
+async function buildSnippetConfigurationWithVersions({ fdr, workspace, snippetsConfig, context: context2 }) {
+  const result = {};
+  const snippetConfigs = [
+    {
+      language: "typescript",
+      snippetName: snippetsConfig.typescriptSdk?.package,
+      explicitVersion: snippetsConfig.typescriptSdk?.version
+    },
+    {
+      language: "python",
+      snippetName: snippetsConfig.pythonSdk?.package,
+      explicitVersion: snippetsConfig.pythonSdk?.version
+    },
+    {
+      language: "java",
+      snippetName: snippetsConfig.javaSdk?.coordinate,
+      explicitVersion: snippetsConfig.javaSdk?.version
+    },
+    {
+      language: "go",
+      snippetName: snippetsConfig.goSdk?.githubRepo,
+      explicitVersion: snippetsConfig.goSdk?.version
+    },
+    {
+      language: "csharp",
+      snippetName: snippetsConfig.csharpSdk?.package,
+      explicitVersion: snippetsConfig.csharpSdk?.version
+    },
+    {
+      language: "ruby",
+      snippetName: snippetsConfig.rubySdk?.gem,
+      explicitVersion: snippetsConfig.rubySdk?.version
+    },
+    {
+      language: "php",
+      snippetName: snippetsConfig.phpSdk?.package,
+      explicitVersion: snippetsConfig.phpSdk?.version
+    },
+    {
+      language: "swift",
+      snippetName: snippetsConfig.swiftSdk?.package,
+      explicitVersion: snippetsConfig.swiftSdk?.version
+    },
+    {
+      language: "rust",
+      snippetName: snippetsConfig.rustSdk?.package,
+      explicitVersion: snippetsConfig.rustSdk?.version
+    }
+  ];
+  for (const config2 of snippetConfigs) {
+    if (!config2.snippetName) {
+      continue;
+    }
+    let version6 = config2.explicitVersion;
+    if (!version6) {
+      const versionResult = await computeSemanticVersionForLanguage({
+        fdr,
+        workspace,
+        language: config2.language,
+        snippetName: config2.snippetName,
+        context: context2
+      });
+      version6 = versionResult?.version;
+    }
+    if (version6) {
+      result[config2.language] = { packageName: config2.snippetName, version: version6 };
+    } else {
+      context2.logger.debug(`[SDK Dynamic IR] ${config2.language}: skipping S3 check (no version available)`);
+    }
+  }
+  return result;
+}
+async function computeSemanticVersionForLanguage({ fdr, workspace, language, snippetName, context: context2 }) {
+  let fdrLanguage;
+  switch (language) {
+    case "csharp":
+      fdrLanguage = "Csharp";
+      break;
+    case "go":
+      fdrLanguage = "Go";
+      break;
+    case "java":
+      fdrLanguage = "Java";
+      break;
+    case "python":
+      fdrLanguage = "Python";
+      break;
+    case "ruby":
+      fdrLanguage = "Ruby";
+      break;
+    case "typescript":
+      fdrLanguage = "TypeScript";
+      break;
+    case "php":
+      fdrLanguage = "Php";
+      break;
+    case "swift":
+      fdrLanguage = "Swift";
+      break;
+    default:
+      return void 0;
+  }
+  let githubRepository;
+  let generatorPackage;
+  let matchedGeneratorName;
+  if (workspace.generatorsConfiguration?.groups) {
+    const candidatePackages = [];
+    for (const group of workspace.generatorsConfiguration.groups) {
+      for (const generatorInvocation of group.generators) {
+        if (generatorInvocation.language === language) {
+          const pkgName = generators_yml_exports.getPackageName({ generatorInvocation });
+          if (pkgName) {
+            candidatePackages.push(pkgName);
+          }
+          if (!generatorPackage && pkgName) {
+            generatorPackage = pkgName;
+            matchedGeneratorName = generatorInvocation.name;
+            if (generatorInvocation.outputMode.type === "githubV2") {
+              githubRepository = `${generatorInvocation.outputMode.githubV2.owner}/${generatorInvocation.outputMode.githubV2.repo}`;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!generatorPackage) {
+    context2.logger.debug(`[SDK Dynamic IR] ${language}: no generator found with a package name`);
+    return void 0;
+  }
+  try {
+    const response = await fdr.sdks.versions.computeSemanticVersion({
+      githubRepository,
+      language: fdrLanguage,
+      package: generatorPackage
+    });
+    if (!response.ok) {
+      context2.logger.debug(`[SDK Dynamic IR] ${language}: version computation failed for package "${generatorPackage}"`);
+      return void 0;
+    }
+    context2.logger.debug(`[SDK Dynamic IR] ${language}: computed version ${response.body.version} for package "${generatorPackage}"`);
+    return { version: response.body.version, generatorPackage };
+  } catch (error2) {
+    context2.logger.debug(`[SDK Dynamic IR] ${language}: error computing version: ${error2}`);
+    return void 0;
+  }
+}
+async function generateLanguageSpecificDynamicIRs({ workspace, organization, context: context2, snippetsConfig, skipLanguages = /* @__PURE__ */ new Set() }) {
   let languageSpecificIRs = {};
   if (!workspace) {
     return void 0;
@@ -1628118,6 +1628380,10 @@ async function generateLanguageSpecificDynamicIRs({ workspace, organization, con
         if (!generatorInvocation.language) {
           continue;
         }
+        if (skipLanguages.has(generatorInvocation.language)) {
+          context2.logger.debug(`Skipping dynamic IR generation for ${generatorInvocation.language} (using existing SDK dynamic IR)`);
+          continue;
+        }
         if (generatorInvocation.language && snippetConfiguration[generatorInvocation.language] === packageName) {
           const irForDynamicSnippets = generateIntermediateRepresentation({
             workspace,
@@ -1628158,7 +1628424,7 @@ async function generateLanguageSpecificDynamicIRs({ workspace, organization, con
     }
   }
   for (const [language, packageName] of Object.entries(snippetConfiguration)) {
-    if (language && packageName && !Object.keys(languageSpecificIRs).includes(language)) {
+    if (language && packageName && !Object.keys(languageSpecificIRs).includes(language) && !skipLanguages.has(language)) {
       context2.logger.warn();
       context2.logger.warn(`Failed to upload ${language} SDK snippets because of unknown package \`${packageName}\`.`);
       context2.logger.warn(`Please make sure your ${workspace.workspaceName ? `${workspace.workspaceName}/` : ""}generators.yml has a generator that publishes a ${packageName} package.`);
@@ -1637803,6 +1638069,30 @@ async function runRulesOnOSSWorkspace({ workspace, context: context2, rules }) {
 
 // src/commands/validate/validateAPIWorkspaceAndLogIssues.ts
 var import_validate_npm_package_name = __toESM(require_lib20(), 1);
+async function collectAPIWorkspaceViolations({
+  workspace,
+  context: context2,
+  ossWorkspace
+}) {
+  if (!(0, import_validate_npm_package_name.default)(workspace.definition.rootApiFile.contents.name).validForNewPackages) {
+    context2.failAndThrow("API name is not valid.");
+  }
+  const startTime = performance.now();
+  const apiViolations = validateFernWorkspace(workspace, context2.logger);
+  const generatorViolations = await validateGeneratorsWorkspace(workspace, context2.logger);
+  const violations = [...apiViolations, ...generatorViolations];
+  if (ossWorkspace) {
+    violations.push(...await validateOSSWorkspace(ossWorkspace, context2));
+  }
+  const elapsedMillis = performance.now() - startTime;
+  const hasErrors = violations.some((v21) => v21.severity === "fatal" || v21.severity === "error");
+  return {
+    apiName: workspace.definition.rootApiFile.contents.name,
+    violations,
+    elapsedMillis,
+    hasErrors
+  };
+}
 async function validateAPIWorkspaceWithoutExiting({
   workspace,
   context: context2,
@@ -1643592,6 +1643882,230 @@ async function validateDocsBrokenLinks({
   });
 }
 
+// src/commands/validate/printCheckReport.ts
+function printCheckReport({ apiResults, docsResult, logWarnings, context: context2 }) {
+  const startTime = performance.now();
+  let hasErrors = false;
+  const apiResultsWithViolations = apiResults.filter((result) => {
+    const stats = getViolationStats2(result.violations);
+    return stats.numErrors > 0 || logWarnings && stats.numWarnings > 0;
+  });
+  if (apiResultsWithViolations.length > 0) {
+    const totalSdkStats = getTotalStats(apiResults.map((r23) => r23.violations).flat());
+    const showApiNesting = apiResults.length > 1;
+    if (showApiNesting) {
+      context2.logger.info(source_default.cyan(source_default.bold("[sdk]")));
+      for (const apiResult of apiResults) {
+        const stats = getViolationStats2(apiResult.violations);
+        if (stats.numErrors > 0 || logWarnings && stats.numWarnings > 0) {
+          hasErrors = hasErrors || stats.numErrors > 0;
+          printApiSection({
+            apiName: apiResult.apiName,
+            violations: apiResult.violations,
+            stats,
+            logWarnings,
+            context: context2,
+            indent: "    "
+          });
+        }
+      }
+    } else {
+      hasErrors = hasErrors || totalSdkStats.numErrors > 0;
+      printSdkSectionFlat({
+        violations: apiResults[0]?.violations ?? [],
+        stats: totalSdkStats,
+        logWarnings,
+        context: context2
+      });
+    }
+  }
+  if (docsResult != null) {
+    const docsStats = getViolationStats2(docsResult.violations);
+    if (docsStats.numErrors > 0 || logWarnings && docsStats.numWarnings > 0) {
+      hasErrors = hasErrors || docsStats.numErrors > 0;
+      printDocsSection({
+        violations: docsResult.violations,
+        stats: docsStats,
+        logWarnings,
+        context: context2
+      });
+    }
+  }
+  const totalElapsedMillis = performance.now() - startTime;
+  const allViolations = [...apiResults.map((r23) => r23.violations).flat(), ...docsResult?.violations ?? []];
+  const totalStats = getViolationStats2(allViolations);
+  printSummary({
+    stats: totalStats,
+    logWarnings,
+    elapsedMillis: totalElapsedMillis,
+    context: context2
+  });
+  return { hasErrors };
+}
+function printSdkSectionFlat({
+  violations,
+  stats,
+  logWarnings,
+  context: context2
+}) {
+  const statsStr = formatStats(stats, logWarnings);
+  context2.logger.info(source_default.cyan(source_default.bold(`[sdk]`)) + ` ${statsStr}`);
+  printViolationsByType({
+    violations,
+    logWarnings,
+    context: context2,
+    indent: "    "
+  });
+}
+function printApiSection({
+  apiName,
+  violations,
+  stats,
+  logWarnings,
+  context: context2,
+  indent: indent3
+}) {
+  const statsStr = formatStats(stats, logWarnings);
+  context2.logger.info(`${indent3}${source_default.bold(`[${apiName}]`)} ${statsStr}`);
+  printViolationsByType({
+    violations,
+    logWarnings,
+    context: context2,
+    indent: indent3 + "    "
+  });
+}
+function printDocsSection({
+  violations,
+  stats,
+  logWarnings,
+  context: context2
+}) {
+  const statsStr = formatStats(stats, logWarnings);
+  context2.logger.info(source_default.magenta(source_default.bold(`[docs]`)) + ` ${statsStr}`);
+  printViolationsByType({
+    violations,
+    logWarnings,
+    context: context2,
+    indent: "    "
+  });
+}
+function printViolationsByType({
+  violations,
+  logWarnings,
+  context: context2,
+  indent: indent3
+}) {
+  const errors4 = violations.filter((v21) => v21.severity === "fatal" || v21.severity === "error");
+  const warnings = violations.filter((v21) => v21.severity === "warning");
+  if (logWarnings) {
+    for (const violation of warnings.sort(sortViolations)) {
+      printViolation({ violation, context: context2, indent: indent3 });
+    }
+  }
+  for (const violation of errors4.sort(sortViolations)) {
+    printViolation({ violation, context: context2, indent: indent3 });
+  }
+}
+function printViolation({
+  violation,
+  context: context2,
+  indent: indent3
+}) {
+  const severityLabel = getSeverityLabel2(violation.severity);
+  const path68 = formatViolationPath(violation);
+  if (path68 === "") {
+    context2.logger.info(`${indent3}${severityLabel} ${violation.message}`);
+  } else {
+    context2.logger.info(`${indent3}${severityLabel}`);
+    context2.logger.info(`${indent3}    path: ${source_default.blue(path68)}`);
+    context2.logger.info(`${indent3}    issue: ${violation.message}`);
+  }
+  context2.logger.info("");
+}
+function formatViolationPath(violation) {
+  const parts = [];
+  if (violation.relativeFilepath !== "") {
+    parts.push(violation.relativeFilepath);
+  }
+  for (const nodePathItem of violation.nodePath) {
+    let itemStr = typeof nodePathItem === "string" ? nodePathItem : nodePathItem.key;
+    if (typeof nodePathItem !== "string" && nodePathItem.arrayIndex != null) {
+      itemStr += `[${nodePathItem.arrayIndex}]`;
+    }
+    parts.push(itemStr);
+  }
+  return parts.join(" -> ");
+}
+function getSeverityLabel2(severity) {
+  switch (severity) {
+    case "fatal":
+      return source_default.red("[error]");
+    case "error":
+      return source_default.red("[error]");
+    case "warning":
+      return source_default.yellow("[warning]");
+    default:
+      assertNever(severity);
+  }
+}
+function formatStats(stats, logWarnings) {
+  const parts = [];
+  if (stats.numErrors > 0) {
+    parts.push(`${stats.numErrors} error${stats.numErrors !== 1 ? "s" : ""}`);
+  }
+  if (logWarnings && stats.numWarnings > 0) {
+    parts.push(`${stats.numWarnings} warning${stats.numWarnings !== 1 ? "s" : ""}`);
+  }
+  return parts.join(", ");
+}
+function getViolationStats2(violations) {
+  let numErrors = 0;
+  let numWarnings = 0;
+  for (const violation of violations) {
+    switch (violation.severity) {
+      case "fatal":
+      case "error":
+        numErrors += 1;
+        break;
+      case "warning":
+        numWarnings += 1;
+        break;
+      default:
+        assertNever(violation.severity);
+    }
+  }
+  return { numErrors, numWarnings };
+}
+function getTotalStats(violations) {
+  return getViolationStats2(violations);
+}
+function sortViolations(a10, b18) {
+  const pathCompare = a10.relativeFilepath.localeCompare(b18.relativeFilepath);
+  if (pathCompare !== 0) {
+    return pathCompare;
+  }
+  return JSON.stringify(a10.nodePath).localeCompare(JSON.stringify(b18.nodePath));
+}
+function printSummary({
+  stats,
+  logWarnings,
+  elapsedMillis,
+  context: context2
+}) {
+  const suffix = elapsedMillis > 0 ? ` in ${(elapsedMillis / 1e3).toFixed(3)} seconds.` : ".";
+  let message = `Found ${stats.numErrors} error${stats.numErrors !== 1 ? "s" : ""} and ${stats.numWarnings} warning${stats.numWarnings !== 1 ? "s" : ""}` + suffix;
+  if (!logWarnings && stats.numWarnings > 0) {
+    message += " Run fern check --warnings to print out the warnings not shown.";
+  }
+  if (stats.numErrors > 0) {
+    context2.logger.error(message);
+  } else if (stats.numWarnings > 0) {
+    context2.logger.warn(message);
+  } else {
+    context2.logger.info(source_default.green("All checks passed"));
+  }
+}
+
 // src/commands/validate/validateWorkspaces.ts
 async function validateWorkspaces({
   project,
@@ -1643602,28 +1644116,41 @@ async function validateWorkspaces({
   isLocal,
   directFromOpenapi
 }) {
+  const apiResults = [];
+  let docsResult;
+  let hasAnyErrors = false;
   const docsWorkspace = project.docsWorkspaces;
   if (docsWorkspace != null) {
+    const excludeRules = brokenLinks || errorOnBrokenLinks ? [] : ["valid-markdown-links"];
+    const ossWorkspaces = await filterOssWorkspaces(project);
+    let collected;
     await cliContext.runTaskForWorkspace(docsWorkspace, async (context2) => {
-      const excludeRules = brokenLinks || errorOnBrokenLinks ? [] : ["valid-markdown-links"];
-      await validateDocsWorkspaceAndLogIssues({
+      collected = await collectDocsWorkspaceViolations({
         workspace: docsWorkspace,
         context: context2,
-        logWarnings,
         apiWorkspaces: project.apiWorkspaces,
-        ossWorkspaces: await filterOssWorkspaces(project),
+        ossWorkspaces,
         errorOnBrokenLinks,
         excludeRules
       });
     });
+    if (collected != null) {
+      docsResult = {
+        violations: collected.violations,
+        elapsedMillis: collected.elapsedMillis
+      };
+      if (collected.hasErrors) {
+        hasAnyErrors = true;
+      }
+    }
   }
   await Promise.all(
     project.apiWorkspaces.map(async (workspace) => {
-      if (workspace.generatorsConfiguration?.groups.length === 0 && workspace.type != "fern") {
+      if (workspace.generatorsConfiguration?.groups.length === 0 && workspace.type !== "fern") {
         return;
       }
-      await cliContext.runTaskForWorkspace(workspace, async (context2) => {
-        if (workspace instanceof OSSWorkspace && directFromOpenapi) {
+      if (workspace instanceof OSSWorkspace && directFromOpenapi) {
+        await cliContext.runTaskForWorkspace(workspace, async (context2) => {
           await workspace.getIntermediateRepresentation({
             context: context2,
             audiences: { type: "all" },
@@ -1643631,18 +1644158,56 @@ async function validateWorkspaces({
             generateV1Examples: false,
             logWarnings
           });
+        });
+        return;
+      }
+      if (workspace instanceof LazyFernWorkspace) {
+        const absolutePathToApiYml = join2(
+          workspace.absoluteFilePath,
+          RelativeFilePath2.of(DEFINITION_DIRECTORY),
+          RelativeFilePath2.of(ROOT_API_FILENAME)
+        );
+        const apiYmlExists = await doesPathExist(absolutePathToApiYml);
+        if (!apiYmlExists) {
+          await cliContext.runTask(async (context2) => {
+            context2.logger.error(`Missing file: ${ROOT_API_FILENAME}`);
+            return context2.failAndThrow();
+          });
           return;
         }
+      }
+      let collected;
+      await cliContext.runTaskForWorkspace(workspace, async (context2) => {
         const fernWorkspace = await workspace.toFernWorkspace({ context: context2 });
-        await validateAPIWorkspaceAndLogIssues({
+        collected = await collectAPIWorkspaceViolations({
           workspace: fernWorkspace,
           context: context2,
-          logWarnings,
           ossWorkspace: workspace instanceof OSSWorkspace ? workspace : void 0
         });
       });
+      if (collected != null) {
+        apiResults.push({
+          apiName: collected.apiName,
+          violations: collected.violations,
+          elapsedMillis: collected.elapsedMillis
+        });
+        if (collected.hasErrors) {
+          hasAnyErrors = true;
+        }
+      }
     })
   );
+  const { hasErrors } = await cliContext.runTask((context2) => {
+    return printCheckReport({
+      apiResults,
+      docsResult,
+      logWarnings,
+      context: context2
+    });
+  });
+  if (hasErrors || hasAnyErrors) {
+    cliContext.failAndThrow();
+  }
 }
 
 // src/commands/write-definition/writeDefinitionForWorkspaces.ts

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.27.2",
+  "version": "3.28.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",