@cparra/apexdocs 3.19.8 → 3.19.9-beta.10

package/dist/cli/generate.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger$1 = require('../logger-BA26xTtD.js');
+var errorCollector = require('../error-collector-hp1dlub7.js');
 var cosmiconfig = require('cosmiconfig');
 var yargs = require('yargs');
 var E = require('fp-ts/Either');
@@ -79,42 +79,42 @@ const markdownOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.markdownDefaults.targetDir,
+    default: errorCollector.markdownDefaults.targetDir,
     describe: "The directory location where documentation will be generated to."
   },
   scope: {
     type: "string",
     array: true,
     alias: "p",
-    default: logger$1.markdownDefaults.scope,
+    default: errorCollector.markdownDefaults.scope,
     describe: "A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled."
   },
   customObjectVisibility: {
     type: "string",
     array: true,
     alias: "v",
-    default: logger$1.markdownDefaults.customObjectVisibility,
+    default: errorCollector.markdownDefaults.customObjectVisibility,
     choices: ["public", "protected", "packageprotected"],
     describe: "Controls which custom objects are documented. Values should be separated by a space."
   },
   defaultGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.defaultGroupName,
+    default: errorCollector.markdownDefaults.defaultGroupName,
     describe: "Defines the @group name to be used when a file does not specify it."
   },
   customObjectsGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.customObjectsGroupName,
+    default: errorCollector.markdownDefaults.customObjectsGroupName,
     describe: "The name under which custom objects will be grouped in the Reference Guide"
   },
   triggersGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.triggersGroupName,
+    default: errorCollector.markdownDefaults.triggersGroupName,
     describe: "The name under which triggers will be grouped in the Reference Guide"
   },
   lwcGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.lwcGroupName,
+    default: errorCollector.markdownDefaults.lwcGroupName,
     describe: "The name under which Lightning Web Components will be grouped in the Reference Guide"
   },
   namespace: {
@@ -124,28 +124,28 @@ const markdownOptions = {
   sortAlphabetically: {
     type: "boolean",
     describe: "Whether to sort files and members alphabetically.",
-    default: logger$1.markdownDefaults.sortAlphabetically
+    default: errorCollector.markdownDefaults.sortAlphabetically
   },
   includeMetadata: {
     type: "boolean",
     describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
-    default: logger$1.markdownDefaults.includeMetadata
+    default: errorCollector.markdownDefaults.includeMetadata
   },
   linkingStrategy: {
     type: "string",
     describe: "The strategy to use when linking to other documentation pages.",
     choices: ["relative", "no-link", "none"],
-    default: logger$1.markdownDefaults.linkingStrategy
+    default: errorCollector.markdownDefaults.linkingStrategy
   },
   referenceGuideTitle: {
     type: "string",
     describe: "The title of the reference guide.",
-    default: logger$1.markdownDefaults.referenceGuideTitle
+    default: errorCollector.markdownDefaults.referenceGuideTitle
   },
   includeFieldSecurityMetadata: {
     type: "boolean",
     describe: "Whether to include the compliance category and security classification for fields in the generated files.",
-    default: logger$1.markdownDefaults.includeFieldSecurityMetadata
+    default: errorCollector.markdownDefaults.includeFieldSecurityMetadata
   },
   includeInlineHelpTextMetadata: {
     type: "boolean",
@@ -154,17 +154,17 @@ const markdownOptions = {
   experimentalLwcSupport: {
     type: "boolean",
     describe: "Enable experimental support for documenting Lightning Web Components (LWC).",
-    default: logger$1.markdownDefaults.experimentalLwcSupport
+    default: errorCollector.markdownDefaults.experimentalLwcSupport
   },
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.markdownDefaults.parallelReflection
+    default: errorCollector.markdownDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.markdownDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.markdownDefaults.parallelReflectionMaxWorkers
   }
 };
 
@@ -200,12 +200,12 @@ const openApiOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.openApiDefaults.targetDir,
+    default: errorCollector.openApiDefaults.targetDir,
     describe: "The directory location where the OpenApi file will be generated."
   },
   fileName: {
     type: "string",
-    default: logger$1.openApiDefaults.fileName,
+    default: errorCollector.openApiDefaults.fileName,
     describe: "The name of the OpenApi file to be generated."
   },
   namespace: {
@@ -214,23 +214,23 @@ const openApiOptions = {
   },
   title: {
     type: "string",
-    default: logger$1.openApiDefaults.title,
+    default: errorCollector.openApiDefaults.title,
     describe: "The title of the OpenApi file."
   },
   apiVersion: {
     type: "string",
-    default: logger$1.openApiDefaults.apiVersion,
+    default: errorCollector.openApiDefaults.apiVersion,
     describe: "The version of the OpenApi file."
   },
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.openApiDefaults.parallelReflection
+    default: errorCollector.openApiDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.openApiDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.openApiDefaults.parallelReflectionMaxWorkers
   }
 };
 
@@ -249,12 +249,12 @@ const changeLogOptions = {
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.markdownDefaults.parallelReflection
+    default: errorCollector.markdownDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.markdownDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.markdownDefaults.parallelReflectionMaxWorkers
   },
   previousVersionDir: {
     type: "string",
@@ -273,32 +273,32 @@ const changeLogOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.changeLogDefaults.targetDir,
+    default: errorCollector.changeLogDefaults.targetDir,
     describe: "The directory location where the changelog file will be generated."
   },
   fileName: {
     type: "string",
-    default: logger$1.changeLogDefaults.fileName,
+    default: errorCollector.changeLogDefaults.fileName,
     describe: "The name of the changelog file to be generated."
   },
   scope: {
     type: "string",
     array: true,
     alias: "s",
-    default: logger$1.changeLogDefaults.scope,
+    default: errorCollector.changeLogDefaults.scope,
     describe: "The list of scope to respect when generating the changelog. Values should be separated by a space, e.g --scope global public namespaceaccessible. Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled."
   },
   customObjectVisibility: {
     type: "string",
     array: true,
     alias: "v",
-    default: logger$1.changeLogDefaults.customObjectVisibility,
+    default: errorCollector.changeLogDefaults.customObjectVisibility,
     choices: ["public", "protected", "packageprotected"],
     describe: "Controls which custom objects are documented. Values should be separated by a space."
   },
   skipIfNoChanges: {
     type: "boolean",
-    default: logger$1.changeLogDefaults.skipIfNoChanges,
+    default: errorCollector.changeLogDefaults.skipIfNoChanges,
     describe: "Skip the changelog generation if there are no changes between the previous and current version."
   }
 };
@@ -406,13 +406,13 @@ function extractArgsForCommandProvidedThroughCli(extractFromProcessFn, config) {
   switch (mergedConfig.targetGenerator) {
     case "markdown":
       return _function.pipe(
-        logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+        errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
         E__namespace.mapLeft((error) => new Error(`Invalid markdown configuration: ${error.message}`)),
         E__namespace.map(() => __spreadValues(__spreadValues({}, configOnlyMarkdownDefaults), mergedConfig))
       );
     case "openapi":
       return _function.pipe(
-        logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+        errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
         E__namespace.mapLeft((error) => new Error(`Invalid openapi configuration: ${error.message}`)),
         E__namespace.map(() => __spreadValues(__spreadValues({}, configOnlyOpenApiDefaults), mergedConfig))
       );
@@ -440,7 +440,7 @@ function extractArgsForCommandsProvidedInConfig(extractFromProcessFn, config) {
           E__namespace.flatMap((cliArgs) => {
             const mergedConfig = __spreadValues(__spreadValues(__spreadValues({}, configOnlyMarkdownDefaults), generatorConfig), cliArgs);
             return _function.pipe(
-              logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+              errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
               E__namespace.mapLeft((error) => new Error(`Invalid markdown configuration: ${error.message}`)),
               E__namespace.map(() => mergedConfig)
             );
@@ -452,7 +452,7 @@ function extractArgsForCommandsProvidedInConfig(extractFromProcessFn, config) {
           E__namespace.flatMap((cliArgs) => {
             const mergedConfig = __spreadValues(__spreadValues(__spreadValues({}, configOnlyOpenApiDefaults), generatorConfig), cliArgs);
             return _function.pipe(
-              logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+              errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
               E__namespace.mapLeft((error) => new Error(`Invalid openapi configuration: ${error.message}`)),
               E__namespace.map(() => mergedConfig)
             );
@@ -557,8 +557,8 @@ function validateChangelogConfig(config) {
   };
   return _function.pipe(
     E__namespace.Do,
-    E__namespace.bind("previousValid", () => logger$1.validateSourceDirectoryConfig(previousVersionConfig)),
-    E__namespace.bind("currentValid", () => logger$1.validateSourceDirectoryConfig(currentVersionConfig)),
+    E__namespace.bind("previousValid", () => errorCollector.validateSourceDirectoryConfig(previousVersionConfig)),
+    E__namespace.bind("currentValid", () => errorCollector.validateSourceDirectoryConfig(currentVersionConfig)),
     E__namespace.map(() => config)
   );
 }
@@ -586,63 +586,54 @@ var __async = (__this, __arguments, generator) => {
 function isDebugEnabledFromProcessArgs() {
   return process.argv.includes("--debug");
 }
-const logger = new logger$1.StdOutLogger();
+const logger = new errorCollector.StdOutLogger();
 logger.setDebug(isDebugEnabledFromProcessArgs());
-const reflectionDebugLogger = logger$1.createReflectionDebugLogger(logger);
 function main() {
-  const aggregatedFailures = [];
-  let commandsRun = 0;
-  function printDebugSummary() {
-    if (!logger.isDebugEnabled()) {
+  function printFailuresAtEnd(collector, config) {
+    if (!collector.hasErrors()) {
       return;
     }
-    logger.debug(`commandsRun=${commandsRun}`);
-    logger.debug(`aggregatedFailures=${aggregatedFailures.length}`);
-  }
-  function printFailuresAtEnd() {
-    if (aggregatedFailures.length === 0) {
-      return;
-    }
-    logger.logSingle("\u26A0\uFE0F Some operations completed with errors. Please review the following issues:", "red");
-    for (const failure of aggregatedFailures) {
-      logger.error(failure);
+    const count = collector.count();
+    logger.logSingle(`\u26A0\uFE0F ${config.targetGenerator}: ${count} error(s) occurred. Please review the following:`, "red");
+    for (const item of collector.all()) {
+      logger.error(errorCollector.ErrorCollector.format(item));
     }
   }
-  function parseResult(result, config) {
-    E__namespace.match(
-      (failure) => {
-        logger.logSingle(`${config.targetGenerator}: completed with errors`, "red");
-        aggregatedFailures.push(failure);
-      },
-      (successMessage) => {
-        logger.logSingle(successMessage);
-      }
-    )(result);
-  }
   function catchUnexpectedError(error) {
     logger.error(`\u274C An error occurred while processing the request: ${error}`);
     process.exit(1);
   }
+  function printResultMessage(result) {
+    if (E__namespace.isRight(result)) {
+      logger.logSingle("Documentation generated successfully");
+    }
+  }
   extractArgs().then((maybeConfigs) => __async(null, null, function* () {
     E__namespace.match(catchUnexpectedError, (configs) => __async(null, null, function* () {
       for (const config of configs) {
-        commandsRun++;
+        const errorCollector$1 = new errorCollector.ErrorCollector(config.targetGenerator);
+        const reflectionDebugLogger = errorCollector.createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+          errorCollector$1.addFailure("other", filePath, errorMessage);
+        });
         if (logger.isDebugEnabled()) {
           logger.debug(`Currently processing generator: ${config.targetGenerator}`);
         }
-        const result = yield logger$1.Apexdocs.generate(config, { logger, reflectionDebugLogger });
+        const result = yield errorCollector.Apexdocs.generate(config, {
+          logger,
+          reflectionDebugLogger,
+          errorCollector: errorCollector$1
+        });
         if (logger.isDebugEnabled()) {
           logger.logSingle(
             `${config.targetGenerator}: ${E__namespace.isRight(result) ? "success" : "failure"}`,
             E__namespace.isRight(result) ? "green" : "red"
           );
         }
-        parseResult(result, config);
-      }
-      printFailuresAtEnd();
-      printDebugSummary();
-      if (aggregatedFailures.length > 0) {
-        process.exitCode = 1;
+        printFailuresAtEnd(errorCollector$1, config);
+        if (errorCollector$1.hasErrors()) {
+          process.exitCode = 1;
+        }
+        printResultMessage(result);
       }
     }))(maybeConfigs);
   })).catch(catchUnexpectedError);

package/dist/{logger-BA26xTtD.js → error-collector-hp1dlub7.js}

@@ -2995,14 +2995,18 @@ var __spreadValues$f = (a, b) => {
   return a;
 };
 var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
-function reflectCustomObjectSources(objectBundles) {
+function reflectCustomObjectSources(objectBundles, debugLogger = noopReflectionDebugLogger) {
   const semiGroupReflectionError = {
     concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
   };
   const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
-  return _function.pipe(objectBundles, A__namespace$1.traverse(Ap)(reflectCustomObjectSource));
+  return _function.pipe(
+    objectBundles,
+    A__namespace$1.traverse(Ap)((bundle) => reflectCustomObjectSource(bundle, debugLogger))
+  );
 }
-function reflectCustomObjectSource(objectSource) {
+function reflectCustomObjectSource(objectSource, debugLogger) {
+  debugLogger.onStart(objectSource.filePath);
   return _function.pipe(
     E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(objectSource.content), E__namespace.toError),
     E__namespace.flatMap(validate$2),
@@ -3011,7 +3015,14 @@ function reflectCustomObjectSource(objectSource) {
     E__namespace.map(parseInlineFields),
     E__namespace.map(addTypeName),
     E__namespace.map((metadata) => toParsedFile$4(objectSource.filePath, metadata)),
-    E__namespace.mapLeft((error) => new ReflectionErrors([new ReflectionError(objectSource.filePath, error.message)])),
+    E__namespace.mapLeft((error) => {
+      debugLogger.onFailure(objectSource.filePath, error.message);
+      return new ReflectionErrors([new ReflectionError(objectSource.filePath, error.message)]);
+    }),
+    E__namespace.map((parsedFile) => {
+      debugLogger.onSuccess(objectSource.filePath);
+      return parsedFile;
+    }),
     TE__namespace.fromEither
   );
 }
@@ -3107,14 +3118,18 @@ var __spreadValues$e = (a, b) => {
   return a;
 };
 var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
-function reflectCustomFieldSources(customFieldSources) {
+function reflectCustomFieldSources(customFieldSources, debugLogger = noopReflectionDebugLogger) {
   const semiGroupReflectionError = {
     concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
   };
   const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
-  return _function.pipe(customFieldSources, A__namespace$1.traverse(Ap)(reflectCustomFieldSource));
+  return _function.pipe(
+    customFieldSources,
+    A__namespace$1.traverse(Ap)((bundle) => reflectCustomFieldSource(bundle, debugLogger))
+  );
 }
-function reflectCustomFieldSource(customFieldSource) {
+function reflectCustomFieldSource(customFieldSource, debugLogger) {
+  debugLogger.onStart(customFieldSource.filePath);
   return _function.pipe(
     E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(customFieldSource.content), E__namespace.toError),
     E__namespace.flatMap(validate$1),
@@ -3122,7 +3137,14 @@ function reflectCustomFieldSource(customFieldSource) {
     E__namespace.map((metadata) => addName(metadata, customFieldSource.name)),
     E__namespace.map((metadata) => addParentName$1(metadata, customFieldSource.parentName)),
     E__namespace.map((metadata) => toParsedFile$3(customFieldSource.filePath, metadata)),
-    E__namespace.mapLeft((error) => new ReflectionErrors([new ReflectionError(customFieldSource.filePath, error.message)])),
+    E__namespace.map((parsed) => {
+      debugLogger.onSuccess(customFieldSource.filePath);
+      return parsed;
+    }),
+    E__namespace.mapLeft((error) => {
+      debugLogger.onFailure(customFieldSource.filePath, error.message);
+      return new ReflectionErrors([new ReflectionError(customFieldSource.filePath, error.message)]);
+    }),
     TE__namespace.fromEither
   );
 }
@@ -3186,10 +3208,14 @@ var __spreadValues$d = (a, b) => {
   return a;
 };
 var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
-function reflectCustomMetadataSources(customMetadataSources) {
-  return _function.pipe(customMetadataSources, A__namespace$1.traverse(TE__namespace.ApplicativePar)(reflectCustomMetadataSource));
+function reflectCustomMetadataSources(customMetadataSources, debugLogger = noopReflectionDebugLogger) {
+  return _function.pipe(
+    customMetadataSources,
+    A__namespace$1.traverse(TE__namespace.ApplicativePar)((bundle) => reflectCustomMetadataSource(bundle, debugLogger))
+  );
 }
-function reflectCustomMetadataSource(customMetadataSource) {
+function reflectCustomMetadataSource(customMetadataSource, debugLogger) {
+  debugLogger.onStart(customMetadataSource.filePath);
   return _function.pipe(
     E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(customMetadataSource.content), E__namespace.toError),
     E__namespace.flatMap(validate),
@@ -3197,7 +3223,14 @@ function reflectCustomMetadataSource(customMetadataSource) {
     E__namespace.map((metadata) => addNames(metadata, customMetadataSource.name, customMetadataSource.apiName)),
     E__namespace.map((metadata) => addParentName(metadata, customMetadataSource.parentName)),
     E__namespace.map((metadata) => toParsedFile$2(customMetadataSource.filePath, metadata)),
-    E__namespace.mapLeft((error) => new ReflectionErrors([new ReflectionError(customMetadataSource.filePath, error.message)])),
+    E__namespace.mapLeft((error) => {
+      debugLogger.onFailure(customMetadataSource.filePath, error.message);
+      return new ReflectionErrors([new ReflectionError(customMetadataSource.filePath, error.message)]);
+    }),
+    E__namespace.map((parsed) => {
+      debugLogger.onSuccess(customMetadataSource.filePath);
+      return parsed;
+    }),
     TE__namespace.fromEither
   );
 }
@@ -3256,7 +3289,7 @@ var __spreadValues$c = (a, b) => {
   return a;
 };
 var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
-function reflectCustomFieldsAndObjectsAndMetadataRecords(objectBundles, visibilitiesToDocument) {
+function reflectCustomFieldsAndObjectsAndMetadataRecords(objectBundles, visibilitiesToDocument, debugLogger = noopReflectionDebugLogger) {
   function filterNonPublished(parsedFiles) {
     return parsedFiles.filter((parsedFile) => parsedFile.type.deploymentStatus === "Deployed");
   }
@@ -3278,14 +3311,14 @@ function reflectCustomFieldsAndObjectsAndMetadataRecords(objectBundles, visibili
     (object) => object.type === "custommetadata"
   );
   function generateForFields(fields) {
-    return _function.pipe(fields, reflectCustomFieldSources);
+    return _function.pipe(fields, (bundles) => reflectCustomFieldSources(bundles, debugLogger));
   }
   function generateForMetadata(metadata) {
-    return _function.pipe(metadata, reflectCustomMetadataSources);
+    return _function.pipe(metadata, (bundles) => reflectCustomMetadataSources(bundles, debugLogger));
   }
   return _function.pipe(
     customObjects,
-    reflectCustomObjectSources,
+    (bundles) => reflectCustomObjectSources(bundles, debugLogger),
     TE__namespace.map(filterNonPublished),
     TE__namespace.map(filter),
     TE__namespace.bindTo("filterResult"),
@@ -3399,19 +3432,36 @@ var __async$4 = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-function reflectTriggerSource(triggerBundles) {
+function reflectTriggerSource(triggerBundles, debugLogger = noopReflectionDebugLogger) {
   const semiGroupReflectionError = {
     concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
   };
   const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
-  return _function.pipe(triggerBundles, A__namespace.traverse(Ap)(reflectBundle$1));
+  return _function.pipe(
+    triggerBundles,
+    A__namespace.traverse(Ap)((bundle) => reflectBundle$1(bundle, debugLogger))
+  );
 }
-function reflectBundle$1(triggerBundle) {
+function reflectBundle$1(triggerBundle, debugLogger) {
   const convertToParsedFile = apply(
     toParsedFile$1,
     triggerBundle.filePath
   );
-  return _function.pipe(triggerBundle, reflectAsTask, TE__namespace.map(convertToParsedFile));
+  debugLogger.onStart(triggerBundle.filePath);
+  return _function.pipe(
+    triggerBundle,
+    reflectAsTask,
+    TE__namespace.map((triggerMirror) => {
+      debugLogger.onSuccess(triggerBundle.filePath);
+      return triggerMirror;
+    }),
+    TE__namespace.map(convertToParsedFile),
+    TE__namespace.mapLeft((errs) => {
+      const msg = errs.errors.map((e) => e.message).join(" | ");
+      debugLogger.onFailure(triggerBundle.filePath, msg);
+      return errs;
+    })
+  );
 }
 function toParsedFile$1(filePath, triggerMirror) {
   return {
@@ -3457,14 +3507,18 @@ var __spreadValues$a = (a, b) => {
     }
   return a;
 };
-function reflectLwcSource(triggerBundles) {
+function reflectLwcSource(triggerBundles, debugLogger = noopReflectionDebugLogger) {
   const semiGroupReflectionError = {
     concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
   };
   const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
-  return _function.pipe(triggerBundles, A__namespace.traverse(Ap)(reflectBundle));
+  return _function.pipe(
+    triggerBundles,
+    A__namespace.traverse(Ap)((bundle) => reflectBundle(bundle, debugLogger))
+  );
 }
-function reflectBundle(lwcBundle) {
+function reflectBundle(lwcBundle, debugLogger) {
+  debugLogger.onStart(lwcBundle.filePath);
   return _function.pipe(
     E__namespace.tryCatch(() => {
       const alwaysArray = [
@@ -3482,8 +3536,15 @@ function reflectBundle(lwcBundle) {
       const bundle = result["LightningComponentBundle"];
       return transformBooleanProperties(bundle);
     }, E__namespace.toError),
+    E__namespace.map((parsed) => {
+      debugLogger.onSuccess(lwcBundle.filePath);
+      return parsed;
+    }),
     E__namespace.map((parsed) => toParsedFile(lwcBundle.filePath, lwcBundle.name, parsed)),
-    E__namespace.mapLeft((error) => new ReflectionErrors([new ReflectionError(lwcBundle.filePath, error.message)])),
+    E__namespace.mapLeft((error) => {
+      debugLogger.onFailure(lwcBundle.filePath, error.message);
+      return new ReflectionErrors([new ReflectionError(lwcBundle.filePath, error.message)]);
+    }),
     TE__namespace.fromEither
   );
 }
@@ -3580,33 +3641,40 @@ function generateDocs(unparsedBundles, config, debugLogger) {
   }
   return _function.pipe(
     TE__namespace.right(replaceMacros(unparsedBundles, config.macros)),
-    TE__namespace.flatMap((unparsedBundles2) => generateForApex(filterApexSourceFiles(unparsedBundles2), config, debugLogger)),
-    TE__namespace.chain((parsedApexFiles) => {
-      return _function.pipe(
-        reflectCustomFieldsAndObjectsAndMetadataRecords(
-          filterCustomObjectsFieldsAndMetadataRecords(unparsedBundles),
-          config.customObjectVisibility
-        ),
-        TE__namespace.map((parsedObjectFiles) => [...parsedApexFiles, ...parsedObjectFiles])
-      );
-    }),
-    TE__namespace.chain((parsedFiles) => {
-      return _function.pipe(
-        reflectTriggerSource(filterTriggerFiles(unparsedBundles)),
-        TE__namespace.map((parsedTriggerFiles) => [...parsedFiles, ...parsedTriggerFiles])
-      );
-    }),
-    TE__namespace.chain((parsedFiles) => {
+    TE__namespace.bindW("unparsedBundles", (unparsedBundles2) => TE__namespace.right(unparsedBundles2)),
+    TE__namespace.bindW(
+      "apex",
+      ({ unparsedBundles: unparsedBundles2 }) => generateForApex(filterApexSourceFiles(unparsedBundles2), config, debugLogger)
+    ),
+    TE__namespace.bindW(
+      "objects",
+      ({ unparsedBundles: unparsedBundles2 }) => reflectCustomFieldsAndObjectsAndMetadataRecords(
+        filterCustomObjectsFieldsAndMetadataRecords(unparsedBundles2),
+        config.customObjectVisibility,
+        debugLogger
+      )
+    ),
+    TE__namespace.bindW(
+      "triggers",
+      ({ unparsedBundles: unparsedBundles2 }) => reflectTriggerSource(filterTriggerFiles(unparsedBundles2), debugLogger)
+    ),
+    TE__namespace.bindW("lwcs", ({ unparsedBundles: unparsedBundles2 }) => {
       if (!config.experimentalLwcSupport) {
-        return TE__namespace.right(parsedFiles);
+        return TE__namespace.right([]);
       }
       return _function.pipe(
-        reflectLwcSource(filterLwcFiles(unparsedBundles)),
-        TE__namespace.map((parsedFiles2) => parsedFiles2.filter((file) => file.type.isExposed)),
-        TE__namespace.map((parsedLwcFiles) => [...parsedFiles, ...parsedLwcFiles])
+        reflectLwcSource(filterLwcFiles(unparsedBundles2), debugLogger),
+        TE__namespace.map((files) => files.filter((file) => file.type.isExposed))
       );
     }),
-    TE__namespace.map((parsedFiles) => sort(filterOutCustomFieldsAndMetadata(parsedFiles))),
+    TE__namespace.flatMap(({ apex, objects, triggers, lwcs }) => {
+      const allParsed = [...apex.parsed, ...objects, ...triggers, ...lwcs];
+      const sorted = sort(filterOutCustomFieldsAndMetadata(allParsed));
+      if (apex.reflectionErrors.errors.length > 0) {
+        return TE__namespace.left(new ReflectionErrors([]));
+      }
+      return TE__namespace.right(sorted);
+    }),
     TE__namespace.bindTo("parsedFiles"),
     TE__namespace.bind(
       "references",
@@ -3666,12 +3734,10 @@ function generateForApex(apexBundles, config, debugLogger) {
       );
       return _function.pipe(
         filtered,
-        TE__namespace.flatMap((parsed) => {
-          if (errors.errors.length > 0) {
-            return TE__namespace.left(errors);
-          }
-          return TE__namespace.right(parsed);
-        })
+        TE__namespace.map((parsed) => ({
+          parsed,
+          reflectionErrors: errors
+        }))
       );
     })
   );
@@ -4752,7 +4818,6 @@ class OpenApiDocsProcessor {
   }
   onProcess(type) {
     var _a, _b;
-    this.logger.logSingle(`Processing ${type.name}`, "green");
     const endpointPath = this.getEndpointPath(type);
     if (!endpointPath) {
       return;
@@ -4788,40 +4853,31 @@ class OpenApiDocsProcessor {
   }
 }
 
-function createReflectionDebugLogger(logger) {
-  if (!logger.isDebugEnabled()) {
+function createReflectionDebugLogger(logger, recordFailure) {
+  if (!logger.isDebugEnabled() && !recordFailure) {
     return noopReflectionDebugLogger;
   }
   return {
     onStart: (filePath) => {
-      logger.debug(`Parsing: ${filePath}...`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath}...`);
+      }
     },
     onSuccess: (filePath) => {
-      logger.debug(`Parsing: ${filePath} OK`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath} OK`);
+      }
     },
     onFailure: (filePath, errorMessage) => {
-      logger.debug(`Parsing: ${filePath} FAILED`);
-      logger.debug(`Parsing error: ${filePath} - ${errorMessage}`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath} FAILED`);
+        logger.debug(`Parsing error: ${filePath} - ${errorMessage}`);
+      }
+      recordFailure == null ? void 0 : recordFailure(filePath, errorMessage);
     }
   };
 }
 
-var __defProp$2 = Object.defineProperty;
-var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$2.call(b, prop))
-      __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b)) {
-      if (__propIsEnum$2.call(b, prop))
-        __defNormalProp$2(a, prop, b[prop]);
-    }
-  return a;
-};
 var __async$2 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -4842,7 +4898,7 @@ var __async$2 = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-function openApi(logger, fileBodies, config) {
+function openApi(logger, fileBodies, config, errorCollector) {
   return __async$2(this, null, function* () {
     const sourceDirectory = (Array.isArray(config.sourceDir) ? config.sourceDir[0] : config.sourceDir) || (fileBodies.length > 0 ? fileBodies[0].filePath.split("/").slice(0, -1).join("/") : process.cwd());
     OpenApiSettings.build({
@@ -4853,7 +4909,9 @@ function openApi(logger, fileBodies, config) {
       namespace: config.namespace,
       version: config.apiVersion
     });
-    const debugLogger = createReflectionDebugLogger(logger);
+    const debugLogger = createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+      errorCollector.addFailure("apex", filePath, errorMessage);
+    });
     const reflectedEither = yield reflectApexSourceBestEffort(
       fileBodies,
       {
@@ -4871,11 +4929,6 @@ function openApi(logger, fileBodies, config) {
         `\u26A0\uFE0F ${recoverableErrors.errors.length} file(s) failed to parse/reflect. Continuing with successfully reflected files.`,
         "red"
       );
-      logger.error(
-        new ReflectionErrors(
-          recoverableErrors.errors.map((e) => __spreadValues$2({}, e))
-        )
-      );
     }
     const reflectionByPath = /* @__PURE__ */ new Map();
     for (const parsed of parsedFiles) {
@@ -4909,11 +4962,12 @@ function openApi(logger, fileBodies, config) {
     }
     ErrorLogger.logErrors(logger, filteredTypes);
     if (recoverableErrors.errors.length > 0) {
-      return E__namespace.left(
-        new ReflectionErrors(
-          recoverableErrors.errors.map((e) => __spreadValues$2({}, e))
-        )
+      errorCollector.addGlobalFailure(
+        "other",
+        `OpenAPI generation completed with ${recoverableErrors.errors.length} reflection error item(s).`,
+        recoverableErrors
       );
+      return E__namespace.left(new ReflectionErrors([]));
     }
     return E__namespace.right(void 0);
   });
@@ -5532,21 +5586,21 @@ function changelogToSourceChangelog(changelog) {
   };
 }
 
-var __defProp$1 = Object.defineProperty;
+var __defProp$2 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
 var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
@@ -5616,7 +5670,8 @@ function generateChangeLog(oldBundles, newBundles, config, debugLogger) {
         ({ bundles: bundles2, apex }) => _function.pipe(
           reflectCustomFieldsAndObjectsAndMetadataRecords(
             filterCustomObjectsFieldsAndMetadataRecords(bundles2),
-            config.customObjectVisibility
+            config.customObjectVisibility,
+            debugLogger
           ),
           TE__namespace.map((parsedObjectFiles) => ({
             parsedFiles: [...apex.parsedFiles, ...parsedObjectFiles],
@@ -5630,7 +5685,7 @@ function generateChangeLog(oldBundles, newBundles, config, debugLogger) {
       TE__namespace.bind(
         "all",
         ({ objects, bundles: bundles2 }) => _function.pipe(
-          reflectTriggerSource(filterTriggerFiles(bundles2)),
+          reflectTriggerSource(filterTriggerFiles(bundles2), debugLogger),
           TE__namespace.map((parsedTriggerFiles) => ({
             parsedFiles: [...objects.parsedFiles, ...parsedTriggerFiles],
             errors: objects.errors
@@ -5676,11 +5731,11 @@ function generateChangeLog(oldBundles, newBundles, config, debugLogger) {
       page: postHookCompile(page),
       combinedReflectionErrors
     })),
-    // Fail at the very end if we had any recoverable Apex reflection errors,
-    // so the CLI can present them after completing the work.
+    // Fail at the very end if we had any recoverable reflection errors,
+    // so the CLI can set an exit code after completing the work.
     TE__namespace.flatMap(({ page, combinedReflectionErrors }) => {
       if (combinedReflectionErrors.errors.length > 0) {
-        return TE__namespace.left(combinedReflectionErrors);
+        return TE__namespace.left(new ReflectionErrors([]));
       }
       return TE__namespace.right(page);
     })
@@ -5706,7 +5761,7 @@ function compile(translations) {
   return (renderable) => {
     const compilationRequest = {
       template: changelogTemplate,
-      source: __spreadProps$1(__spreadValues$1({}, renderable), {
+      source: __spreadProps$1(__spreadValues$2({}, renderable), {
         title: translations.changelog.title
       })
     };
@@ -5732,14 +5787,14 @@ function transformChangelogPage(_0) {
     if (isSkip(page)) {
       return page;
     }
-    return __spreadValues$1(__spreadValues$1({}, page), yield hook(page));
+    return __spreadValues$2(__spreadValues$2({}, page), yield hook(page));
   });
 }
 function postHookCompile(page) {
   if (isSkip(page)) {
     return page;
   }
-  return __spreadProps$1(__spreadValues$1({}, page), {
+  return __spreadProps$1(__spreadValues$2({}, page), {
     content: Template.getInstance().compile({
       source: {
         frontmatter: toFrontmatterString(page.frontmatter),
@@ -5770,21 +5825,21 @@ function writeFilesToSystem(pageData, outputDir) {
   );
 }
 
-var __defProp = Object.defineProperty;
+var __defProp$1 = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
     }
   return a;
 };
@@ -5978,7 +6033,7 @@ function processFiles(fileSystem, config) {
         (components) => {
           return components.map((component) => {
             const pathLocation = component.type.name === "ApexClass" ? component.content : component.xml;
-            return __spreadProps(__spreadValues({}, component), {
+            return __spreadProps(__spreadValues$1({}, component), {
               filePath: pathLocation
             });
           });
@@ -6176,15 +6231,15 @@ class Apexdocs {
    */
   static generate(config, deps) {
     return __async(this, null, function* () {
-      const { logger, reflectionDebugLogger } = deps;
+      const { logger, reflectionDebugLogger, errorCollector } = deps;
       logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
       try {
         switch (config.targetGenerator) {
           case "markdown": {
-            return (yield processMarkdown(config, logger, reflectionDebugLogger))();
+            return (yield processMarkdown(config, logger, reflectionDebugLogger, errorCollector))();
           }
           case "openapi": {
-            const task = yield processOpenApi(config, logger);
+            const task = yield processOpenApi(config, logger, errorCollector);
             const openApiResult = yield task();
             if (E__namespace.isLeft(openApiResult)) {
               return E__namespace.left([openApiResult.left]);
@@ -6192,48 +6247,57 @@ class Apexdocs {
             return E__namespace.right("\u2714\uFE0F Documentation generated successfully!");
           }
           case "changelog": {
-            return (yield processChangeLog(config, logger, reflectionDebugLogger))();
+            return (yield processChangeLog(config, logger, reflectionDebugLogger, errorCollector))();
           }
         }
       } catch (error) {
+        errorCollector.addGlobalFailure("other", String(error), error);
         return E__namespace.left([error]);
       }
     });
   }
 }
 const readFiles = apply(processFiles, new DefaultFileSystem());
-function processMarkdown(config, logger, reflectionDebugLogger) {
+function processMarkdown(config, logger, reflectionDebugLogger, errorCollector) {
   return __async(this, null, function* () {
     const debugLogger = reflectionDebugLogger;
     return _function.pipe(
       resolveAndValidateSourceDirectories(config),
-      E__namespace.mapLeft((error) => new FileReadingError(`Failed to resolve source directories: ${error.message}`, error)),
+      E__namespace.mapLeft((error) => {
+        errorCollector.addGlobalFailure("read", `Failed to resolve source directories: ${error.message}`, error);
+        return new FileReadingError(`Failed to resolve source directories: ${error.message}`, error);
+      }),
       E__namespace.flatMap(
         (sourceDirs) => E__namespace.tryCatch(
           () => readFiles({ experimentalLwcSupport: config.experimentalLwcSupport })(allComponentTypes, {
             includeMetadata: config.includeMetadata
           })(sourceDirs, config.exclude),
-          (e) => new FileReadingError("An error occurred while reading files.", e)
+          (e) => {
+            errorCollector.addGlobalFailure("read", "An error occurred while reading files.", e);
+            return new FileReadingError("An error occurred while reading files.", e);
+          }
         )
       ),
       TE__namespace.fromEither,
       TE__namespace.flatMap((fileBodies) => generate$1(fileBodies, config, debugLogger)),
       TE__namespace.map(() => "\u2714\uFE0F Documentation generated successfully!"),
       TE__namespace.mapLeft((err) => {
-        const errors = toErrors(err);
         if (logger.isDebugEnabled()) {
-          logger.debug(`markdown generator finished with ${Array.isArray(errors) ? errors.length : 1} error item(s)`);
+          logger.debug(`markdown generator finished with errors`);
         }
-        return errors;
+        return toErrors(err);
       })
     );
   });
 }
-function processOpenApi(config, logger) {
+function processOpenApi(config, logger, errorCollector) {
   return __async(this, null, function* () {
     return _function.pipe(
       resolveAndValidateSourceDirectories(config),
-      E__namespace.mapLeft((error) => new FileReadingError(`Failed to resolve source directories: ${error.message}`, error)),
+      E__namespace.mapLeft((error) => {
+        errorCollector.addGlobalFailure("read", `Failed to resolve source directories: ${error.message}`, error);
+        return new FileReadingError(`Failed to resolve source directories: ${error.message}`, error);
+      }),
       TE__namespace.fromEither,
       TE__namespace.flatMap(
         (sourceDirs) => TE__namespace.tryCatch(
@@ -6242,15 +6306,18 @@ function processOpenApi(config, logger) {
               sourceDirs,
               config.exclude
             );
-            return openApi(logger, fileBodies, config);
+            return openApi(logger, fileBodies, config, errorCollector);
           },
-          (e) => new FileReadingError("An error occurred while generating OpenAPI documentation.", e)
+          (e) => {
+            errorCollector.addGlobalFailure("other", "An error occurred while generating OpenAPI documentation.", e);
+            return new FileReadingError("An error occurred while generating OpenAPI documentation.", e);
+          }
         )
       )
     );
   });
 }
-function processChangeLog(config, logger, reflectionDebugLogger) {
+function processChangeLog(config, logger, reflectionDebugLogger, errorCollector) {
   return __async(this, null, function* () {
     function loadFiles() {
       const previousVersionConfig = {
@@ -6265,24 +6332,47 @@ function processChangeLog(config, logger, reflectionDebugLogger) {
           "previousVersionDirs",
           () => _function.pipe(
             resolveAndValidateSourceDirectories(previousVersionConfig),
-            E__namespace.mapLeft(
-              (error) => new FileReadingError(`Failed to resolve previous version source directories: ${error.message}`, error)
-            )
+            E__namespace.mapLeft((error) => {
+              errorCollector.addGlobalFailure(
+                "read",
+                `Failed to resolve previous version source directories: ${error.message}`,
+                error
+              );
+              return new FileReadingError(
+                `Failed to resolve previous version source directories: ${error.message}`,
+                error
+              );
+            })
           )
         ),
         E__namespace.bind(
           "currentVersionDirs",
           () => _function.pipe(
             resolveAndValidateSourceDirectories(currentVersionConfig),
-            E__namespace.mapLeft(
-              (error) => new FileReadingError(`Failed to resolve current version source directories: ${error.message}`, error)
-            )
+            E__namespace.mapLeft((error) => {
+              errorCollector.addGlobalFailure(
+                "read",
+                `Failed to resolve current version source directories: ${error.message}`,
+                error
+              );
+              return new FileReadingError(
+                `Failed to resolve current version source directories: ${error.message}`,
+                error
+              );
+            })
           )
         ),
-        E__namespace.map(({ previousVersionDirs, currentVersionDirs }) => [
-          readFiles({ experimentalLwcSupport: false })(allComponentTypes)(previousVersionDirs, config.exclude),
-          readFiles({ experimentalLwcSupport: false })(allComponentTypes)(currentVersionDirs, config.exclude)
-        ])
+        E__namespace.map(({ previousVersionDirs, currentVersionDirs }) => {
+          const previous = readFiles({ experimentalLwcSupport: false })(allComponentTypes)(
+            previousVersionDirs,
+            config.exclude
+          );
+          const current = readFiles({ experimentalLwcSupport: false })(allComponentTypes)(
+            currentVersionDirs,
+            config.exclude
+          );
+          return [previous, current];
+        })
       );
     }
     return _function.pipe(
@@ -6290,11 +6380,10 @@ function processChangeLog(config, logger, reflectionDebugLogger) {
       TE__namespace.fromEither,
       TE__namespace.flatMap(([previous, current]) => generate(previous, current, config, reflectionDebugLogger)),
       TE__namespace.mapLeft((err) => {
-        const errors = toErrors(err);
         if (logger.isDebugEnabled()) {
-          logger.debug(`changelog generator finished with ${Array.isArray(errors) ? errors.length : 1} error item(s)`);
+          logger.debug(`changelog generator finished with errors`);
         }
-        return errors;
+        return toErrors(err);
       })
     );
   });
@@ -6385,7 +6474,70 @@ class NoLogger {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class ErrorCollector {
+  constructor(generator) {
+    this.items = [];
+    this.generator = generator;
+  }
+  add(item) {
+    var _a;
+    const fullItem = __spreadValues({
+      generator: this.generator,
+      at: (_a = item.at) != null ? _a : (/* @__PURE__ */ new Date()).toISOString()
+    }, item);
+    this.items.push(fullItem);
+  }
+  addFailure(stage, filePath, message, raw) {
+    this.add({
+      stage,
+      filePath,
+      message,
+      raw
+    });
+  }
+  addGlobalFailure(stage, message, raw) {
+    this.add({
+      stage,
+      message,
+      raw
+    });
+  }
+  hasErrors() {
+    return this.items.length > 0;
+  }
+  count() {
+    return this.items.length;
+  }
+  all() {
+    return this.items;
+  }
+  /**
+   * Human-readable representation of the error item.
+   */
+  static format(item) {
+    const location = item.filePath ? `${item.filePath}` : "";
+    return `[${item.generator}] ${location}: ${item.message} - ${item.raw}`;
+  }
+}
+
 exports.Apexdocs = Apexdocs;
+exports.ErrorCollector = ErrorCollector;
 exports.NoLogger = NoLogger;
 exports.StdOutLogger = StdOutLogger;
 exports.changeLogDefaults = changeLogDefaults;

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger = require('./logger-BA26xTtD.js');
+var errorCollector = require('./error-collector-hp1dlub7.js');
 var E = require('fp-ts/Either');
 require('fp-ts/function');
 require('fp-ts/TaskEither');
@@ -82,15 +82,26 @@ var __async = (__this, __arguments, generator) => {
 };
 function process(config) {
   return __async(this, null, function* () {
-    const logger$1 = new logger.NoLogger();
-    const reflectionDebugLogger = logger.createReflectionDebugLogger(logger$1);
+    const logger = new errorCollector.NoLogger();
     const configWithDefaults = __spreadValues$1(__spreadValues$1({}, getDefault(config)), config);
     if (!configWithDefaults.sourceDir) {
       throw new Error("sourceDir is required");
     }
-    const result = yield logger.Apexdocs.generate(configWithDefaults, { logger: logger$1, reflectionDebugLogger });
+    const errorCollector$1 = new errorCollector.ErrorCollector(configWithDefaults.targetGenerator);
+    const reflectionDebugLogger = errorCollector.createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+      errorCollector$1.addFailure("other", filePath, errorMessage);
+    });
+    const result = yield errorCollector.Apexdocs.generate(configWithDefaults, {
+      logger,
+      reflectionDebugLogger,
+      errorCollector: errorCollector$1
+    });
     E__namespace.match(
       (errors) => {
+        if (errorCollector$1.hasErrors()) {
+          const details = errorCollector$1.all().map(errorCollector.ErrorCollector.format).join("\n");
+          throw new Error(details);
+        }
         throw errors;
       },
       () => {
@@ -101,11 +112,11 @@ function process(config) {
 function getDefault(config) {
   switch (config.targetGenerator) {
     case "markdown":
-      return logger.markdownDefaults;
+      return errorCollector.markdownDefaults;
     case "openapi":
-      return logger.openApiDefaults;
+      return errorCollector.openApiDefaults;
     case "changelog":
-      return logger.changeLogDefaults;
+      return errorCollector.changeLogDefaults;
     default:
       throw new Error("Unknown target generator");
   }
@@ -131,23 +142,23 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 function defineMarkdownConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.markdownDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.markdownDefaults), config), {
     targetGenerator: "markdown"
   });
 }
 function defineOpenApiConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.openApiDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.openApiDefaults), config), {
     targetGenerator: "openapi"
   });
 }
 function defineChangelogConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.changeLogDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.changeLogDefaults), config), {
     targetGenerator: "changelog"
   });
 }
 
-exports.skip = logger.skip;
-exports.templateHelpers = logger.templateHelpers;
+exports.skip = errorCollector.skip;
+exports.templateHelpers = errorCollector.templateHelpers;
 exports.defineChangelogConfig = defineChangelogConfig;
 exports.defineMarkdownConfig = defineMarkdownConfig;
 exports.defineOpenApiConfig = defineOpenApiConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.19.8",
+  "version": "3.19.9-beta.10",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "engines": {
     "node": ">=18"
@@ -96,7 +96,7 @@
     ]
   },
   "dependencies": {
-    "@cparra/apex-reflection": "2.23.10",
+    "@cparra/apex-reflection": "2.23.10-dev.20260107145611",
     "@salesforce/source-deploy-retrieve": "^12.20.1",
     "@types/js-yaml": "^4.0.9",
     "@types/yargs": "^17.0.32",