@astryxdesign/cli 0.6.4-canary.06c8fa3 → 0.6.4-canary.10dd683

package/api/component/component.mjs

@@ -4,10 +4,10 @@
  * @file Programmatic API for the component command — DISPATCHER + BARREL.
  *
  * Returns the same typed envelope { type, data } that `astryx --json component`
- * outputs. `component(name, opts)` parses one selector or an ordered selector
- * list, resolves each subject through `_adapter`, and routes to the correct leaf
- * (list · detail · detail.props/source/showcase/blocks). The CLI command handler
- * is a thin wrapper around this function.
+ * outputs. `component(name, opts)` parses the (name, options) pair, resolves the
+ * subject once via `_adapter`, and routes to the correct leaf
+ * (list · detail · detail.props/source/showcase/blocks), returning that leaf's
+ * envelope. The CLI command handler is a thin wrapper around this function.
  *
  * Every leaf is also re-exported for direct scripting use.
  */
@@ -26,8 +26,6 @@ import {
   resolveUnscopedDoc,
   loadComponentDoc,
   scopeSubComponent,
-  ComponentAmbiguityError,
-  installedComponentPackageVersion,
 } from './_adapter.mjs';
 import {componentList} from './list/list.mjs';
 import {componentDetail} from './detail/detail.mjs';
@@ -36,199 +34,13 @@ import {componentDetailSource} from './detail/source/source.mjs';
 import {componentDetailShowcase} from './detail/showcase/showcase.mjs';
 import {componentDetailBlocks} from './detail/blocks/blocks.mjs';
 
-/** Maximum selectors accepted before any component resolution starts. */
-export const COMPONENT_BATCH_SELECTOR_LIMIT = 100;
-
 /** @type {ReadonlyArray<string>} */
 const DETAIL_LEVELS = ['full', 'compact', 'brief'];
 /** @type {ReadonlyArray<string>} */
 const LANGS = ['en', 'zh', 'dense'];
-/** @type {Set<string>} */
-const NOT_FOUND_CODES = new Set([
-  ERROR_CODES.ERR_UNKNOWN_COMPONENT,
-  ERROR_CODES.ERR_UNKNOWN_PACKAGE,
-  ERROR_CODES.ERR_NOT_FOUND,
-]);
-
-/**
- * Discover-compatible package target grammar. Versions belong to the package
- * head, never the item after the package slash.
- * @param {string} selector
- * @returns {{scoped: boolean, name: string, version?: string, item?: string}}
- */
-function splitSelector(selector) {
-  const scoped = selector.startsWith('@');
-  const firstSlash = selector.indexOf('/');
-  let head = selector;
-  /** @type {string | undefined} */
-  let rest;
-  const split = scoped
-    ? firstSlash < 0
-      ? -1
-      : selector.indexOf('/', firstSlash + 1)
-    : firstSlash;
-  if (split > 0) {
-    head = selector.slice(0, split);
-    rest = selector.slice(split + 1) || undefined;
-  }
-  const at = head.indexOf('@', 1);
-  return {
-    scoped,
-    name: at > 0 ? head.slice(0, at) : head,
-    ...(at > 0 && head.slice(at + 1) ? {version: head.slice(at + 1)} : {}),
-    ...(rest ? {item: rest} : {}),
-  };
-}
-
-/**
- * Resolve one component selector into the existing single-component API inputs.
- * @param {unknown} value
- * @param {string|undefined} packageScope
- * @returns {{selector: string, name: string, package?: string, version?: string}}
- */
-function parseComponentSelector(value, packageScope) {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new AstryxError(
-      `Invalid component selector "${String(value)}"`,
-      undefined,
-      ERROR_CODES.ERR_INVALID_ARGUMENT,
-    );
-  }
-  const target = splitSelector(value);
-  const packageShaped =
-    target.scoped || target.item != null || target.version != null;
-  if (!packageShaped) {
-    return {selector: value, name: target.name, package: packageScope};
-  }
-  if (!target.item) {
-    throw new AstryxError(
-      `Component selector "${value}" names a package but no component`,
-      undefined,
-      ERROR_CODES.ERR_INVALID_ARGUMENT,
-    );
-  }
-  if (packageScope && packageScope !== target.name) {
-    throw new AstryxError(
-      `Component selector "${value}" conflicts with --package "${packageScope}"`,
-      undefined,
-      ERROR_CODES.ERR_INVALID_ARGUMENT,
-    );
-  }
-  return {
-    selector: value,
-    name: target.item,
-    package: target.name,
-    ...(target.version ? {version: target.version} : {}),
-  };
-}
-
-/**
- * A version-qualified selector never falls through to another installed
- * version. Its structured suggestion points at the command that can discover
- * the requested package release.
- * @param {{package?: string, version?: string}} target
- * @param {string} coreDir
- * @param {import('../../foundation/integrations/integrations.mjs').LoadedIntegration[]} loadedIntegrations
- * @returns {void}
- */
-function requireInstalledSelectorVersion(target, coreDir, loadedIntegrations) {
-  if (!target.version) return;
-  const packageName = /** @type {string} */ (target.package);
-  const installed = installedComponentPackageVersion(
-    coreDir,
-    loadedIntegrations,
-    packageName,
-  );
-  if (installed === target.version) return;
-  const exact = `${packageName}@${target.version}`;
-  throw new AstryxError(
-    `Package "${exact}" is not installed`,
-    [
-      {
-        name: `astryx discover ${exact}`,
-        reason: 'look up this package version',
-      },
-    ],
-    ERROR_CODES.ERR_UNKNOWN_PACKAGE,
-  );
-}
-
-/**
- * Turn a single-lookup failure into one complete batch row.
- * @param {string} selector
- * @param {unknown} error
- * @returns {import('./component.type.mjs').ComponentBatchResult}
- */
-function batchFailure(selector, error) {
-  const err =
-    error instanceof AstryxError
-      ? error
-      : new AstryxError(
-          error instanceof Error ? error.message : String(error),
-          undefined,
-          ERROR_CODES.ERR_UNKNOWN,
-        );
-  if (err instanceof ComponentAmbiguityError) {
-    return {
-      selector,
-      status: 'ambiguous',
-      code: err.code,
-      error: err.message,
-      candidates: err.candidates,
-    };
-  }
-  return {
-    selector,
-    status: NOT_FOUND_CODES.has(err.code) ? 'not_found' : 'error',
-    code: err.code,
-    error: err.message,
-    ...(err.suggestions ? {suggestions: err.suggestions} : {}),
-  };
-}
 
 /**
- * @param {unknown[]} selectors
- * @param {object} options
- * @param {string} options.cwd
- * @param {string} [options.package]
- * @param {boolean} [options.props]
- * @param {boolean} [options.source]
- * @param {boolean} [options.showcase]
- * @param {boolean} [options.blocks]
- * @param {'full'|'compact'|'brief'} [options.detail]
- * @param {string|null} [options.lang]
- * @param {boolean} [options.zh]
- * @param {boolean} [options.dense]
- * @param {string} coreDir
- * @returns {Promise<import('./component.type.mjs').ComponentBatchResponse>}
- */
-async function componentBatch(selectors, options, coreDir) {
-  const loadedIntegrations = await loadIntegrationsSafely(options.cwd);
-  /** @type {import('./component.type.mjs').ComponentBatchResult[]} */
-  const results = [];
-  for (const value of selectors) {
-    const selector = typeof value === 'string' ? value : String(value);
-    try {
-      const target = parseComponentSelector(value, options.package);
-      requireInstalledSelectorVersion(target, coreDir, loadedIntegrations);
-      const result =
-        /** @type {import('./component.type.mjs').ComponentSingleResponse} */ (
-          await component(target.name, {
-            ...options,
-            lang: options.lang ?? undefined,
-            package: target.package,
-          })
-        );
-      results.push({selector, status: 'found', result});
-    } catch (error) {
-      results.push(batchFailure(selector, error));
-    }
-  }
-  return {type: 'component.batch', data: {count: results.length, results}};
-}
-
-/**
- * @param {string|string[]} [name]
+ * @param {string} [name]
  * @param {object} [options]
  * @param {string} [options.cwd]
  * @param {boolean} [options.list]
@@ -244,7 +56,6 @@ async function componentBatch(selectors, options, coreDir) {
  * @param {boolean} [options.dense]
  * @returns {Promise<(
  *   import('./component.type.mjs').ComponentListResponse
- *   | import('./component.type.mjs').ComponentBatchResponse
  *   | import('./component.type.mjs').ComponentDetailResponse
  *   | import('./component.type.mjs').ComponentDetailPropsResponse
  *   | import('./component.type.mjs').ComponentDetailSourceResponse
@@ -268,16 +79,11 @@ export async function component(name, options = {}) {
     dense = false,
   } = options;
 
-  const selectorList = Array.isArray(name) ? name : null;
-  const noName = selectorList == null && !name;
-
   // Default detail level mirrors the CLI (see commands/component/index.mjs):
   // single-component views default to 'full', list-style views (--list,
   // --category, or no name) default to 'brief' (scannable name lists).
-  // An explicit array remains a batch even when it is empty or a caller also
-  // passes a list-only option.
-  const isListView =
-    selectorList == null && (list || category != null || noName);
+  // Keeping this in sync with the CLI is what the API↔CLI parity test checks.
+  const isListView = list || category != null || !name;
   const detail = detailOption ?? (isListView ? 'brief' : 'full');
 
   // Same accepted values and codes as the CLI's --detail and --lang, checked
@@ -297,14 +103,6 @@ export async function component(name, options = {}) {
     );
   }
 
-  if (selectorList && selectorList.length > COMPONENT_BATCH_SELECTOR_LIMIT) {
-    throw new AstryxError(
-      `Component batch accepts at most ${COMPONENT_BATCH_SELECTOR_LIMIT} selectors; received ${selectorList.length}`,
-      undefined,
-      ERROR_CODES.ERR_INVALID_ARGUMENT,
-    );
-  }
-
   const coreDir = requireCoreDir(cwd);
 
   // A public API caller could pass a non-string category; the list leaf does
@@ -318,46 +116,11 @@ export async function component(name, options = {}) {
     );
   }
 
-  // ── Explicit batch selector list ─────────────────────────────────
-  // Array shape owns cardinality even if a caller also supplies a list-only
-  // option. The aggregate limit above is checked before core or integrations
-  // are resolved, so an oversized request can never emit a partial receipt.
-  if (selectorList) {
-    return componentBatch(
-      selectorList,
-      {
-        cwd,
-        package: packageScope,
-        props,
-        source,
-        showcase,
-        blocks,
-        detail,
-        lang,
-        zh,
-        dense,
-      },
-      coreDir,
-    );
-  }
-
   // ── List mode ──────────────────────────────────────────────────
-  if (category || list || noName) {
+  if (category || list || !name) {
     return componentList(coreDir, {cwd, category, detail, zh, dense, lang});
   }
 
-  if (typeof name === 'string') {
-    const target = parseComponentSelector(name, packageScope);
-    if (target.version) {
-      const loadedIntegrations = await loadIntegrationsSafely(cwd);
-      requireInstalledSelectorVersion(target, coreDir, loadedIntegrations);
-    }
-    if (target.name !== name || target.package !== packageScope) {
-      return component(target.name, {...options, package: target.package});
-    }
-    name = target.name;
-  }
-
   // ── Single component ───────────────────────────────────────────
   if (typeof name !== 'string') {
     throw new AstryxError(
@@ -423,10 +186,7 @@ export async function component(name, options = {}) {
     if (extDocPath) {
       // Legacy packages ship docs, never source.
       if (source) {
-        return componentDetailSource(dirName, null, {
-          name,
-          notFoundInPackage: packageScope,
-        });
+        return componentDetailSource(dirName, null, {name, notFoundInPackage: packageScope});
       }
       if (blocks) {
         return componentDetailBlocks(dirName, cwd);

package/api/component/component.type.d.mts

@@ -28,31 +28,6 @@ export type ComponentListData = ({
     detail: "full";
     components: Record<string, import("@astryxdesign/cli/authoring").ComponentDoc[]>;
 });
-/**
- * `component(string[])` always returns this type, including empty and one-item
- * arrays. The CLI returns it for two or more positional selectors.
- */
-export type ComponentBatchResponse = import("../../foundation/response/batch.type.mjs").BatchResponse<"component.batch", ComponentSingleResponse, ComponentBatchCandidate>;
-/**
- * One installed component that makes an unqualified selector ambiguous.
- * Keys match a component row in `discover.search` so a caller does not learn a
- * second candidate shape.
- */
-export type ComponentBatchCandidate = {
-    package: string;
-    component: string;
-    kind: "component";
-    installed: true;
-};
-/**
- * The response a successful single selector would have returned.
- */
-export type ComponentSingleResponse = (ComponentDetailResponse | ComponentDetailPropsResponse | ComponentDetailSourceResponse | ComponentDetailShowcaseResponse | ComponentDetailBlocksResponse);
-/**
- * One row per requested selector, in argument order. Duplicate selectors keep
- * duplicate rows.
- */
-export type ComponentBatchResult = import("../../foundation/response/batch.type.mjs").BatchRow<ComponentSingleResponse, ComponentBatchCandidate>;
 /**
  * A single entry in a `component.list` group at `detail: 'names'`. Pre-1.0 the
  * list moved from bare strings to package-qualified objects so consumers can

package/api/component/component.type.mjs

@@ -18,9 +18,6 @@
  * astryx --json component --category Form         -> component.list (filtered)
  * astryx --json component --list --detail compact -> component.list (data.detail='compact')
  * astryx --json component --list --detail full    -> component.list (data.detail='full')
- * component([])                                  -> component.batch (data.count=0)
- * component(['Button'])                          -> component.batch (data.count=1)
- * astryx --json component Button Badge            -> component.batch
  * astryx --json component Button                  -> component.detail
  * astryx --json component Button --props          -> component.detail.props
  * astryx --json component Button --source         -> component.detail.source
@@ -52,47 +49,6 @@
  * )} ComponentListData
  */
 
-/**
- * `component(string[])` always returns this type, including empty and one-item
- * arrays. The CLI returns it for two or more positional selectors.
- * @typedef {import('../../foundation/response/batch.type.mjs').BatchResponse<
- *   'component.batch',
- *   ComponentSingleResponse,
- *   ComponentBatchCandidate
- * >} ComponentBatchResponse
- */
-
-/**
- * One installed component that makes an unqualified selector ambiguous.
- * Keys match a component row in `discover.search` so a caller does not learn a
- * second candidate shape.
- * @typedef {object} ComponentBatchCandidate
- * @property {string} package
- * @property {string} component
- * @property {'component'} kind
- * @property {true} installed
- */
-
-/**
- * The response a successful single selector would have returned.
- * @typedef {(
- *   | ComponentDetailResponse
- *   | ComponentDetailPropsResponse
- *   | ComponentDetailSourceResponse
- *   | ComponentDetailShowcaseResponse
- *   | ComponentDetailBlocksResponse
- * )} ComponentSingleResponse
- */
-
-/**
- * One row per requested selector, in argument order. Duplicate selectors keep
- * duplicate rows.
- * @typedef {import('../../foundation/response/batch.type.mjs').BatchRow<
- *   ComponentSingleResponse,
- *   ComponentBatchCandidate
- * >} ComponentBatchResult
- */
-
 /**
  * A single entry in a `component.list` group at `detail: 'names'`. Pre-1.0 the
  * list moved from bare strings to package-qualified objects so consumers can

package/api/docs/docs.test.mjs

@@ -146,7 +146,6 @@ describe('docs() dispatcher routing', () => {
     // A guide moves across its namespace's slot, as any tree node does.
     expect(index.data.links).toEqual({
       up: 'astryx docs cli',
-      previous: 'astryx docs cli/component-lookups',
       next: 'astryx docs cli/writing-docs',
     });
     const first = (await docs('cli/integrations', index.data.sections[0].id)).data;
@@ -210,7 +209,6 @@ describe('docs() dispatcher routing', () => {
     expect(err).toBeInstanceOf(AstryxError);
     expect(err.code).toBe('ERR_UNKNOWN_SECTION');
     expect(err.suggestions.map(s => s.name)).toEqual([
-      'cli/component-lookups',
       'cli/integrations',
       'cli/writing-docs',
       'cli/commands',

package/api/doctor/doctor.d.mts

@@ -257,20 +257,15 @@ export type DoctorContext = {
      * could not be built, when it could not.
      */
     docsCatalogError?: string | null | undefined;
+    /**
+     * Combined project-level integration issues, including cross-package template replacement warnings.
+     */
     integrationIssues?: {
         package: string;
         code: string;
         severity: "warning" | "error";
         message: string;
     }[] | null | undefined;
-    /**
-     * installed dependencies whose integration manifest could not be loaded
-     * Combined project-level integration issues, including cross-package template replacement warnings.
-     */
-    autolinkFailures?: {
-        spec: string;
-        error: string;
-    }[] | null | undefined;
     /**
      * - Error thrown while resolving the config
      * path (e.g. multiple config files present), surfaced by checkConfig as a FAIL.

package/api/doctor/doctor.mjs

@@ -26,11 +26,7 @@ import * as path from 'node:path';
 import {MIN_NODE_VERSION, isNodeVersionSupported} from '../../foundation/env/node-version.mjs';
 import {CLI_ROOT, findCoreDir, findInstalledPackage} from '../../foundation/fs/paths.mjs';
 import {explainPackageManager, getCliInvocation} from '../../foundation/env/package-manager.mjs';
-import {
-  findConfigPath,
-  Project,
-  providerLedgerOf,
-} from '../../foundation/config/project.mjs';
+import {findConfigPath, Project} from '../../foundation/config/project.mjs';
 import {DocsCatalog} from '../../foundation/discovery/docs-discovery.mjs';
 import {buildDocsIndexData} from '../../foundation/discovery/docs-section-key.mjs';
 import {
@@ -80,8 +76,6 @@ import {semverCompare, isValidSemver, satisfiesRange} from '../../foundation/env
  * @property {string|null} [docsCatalogError] - Why the project's docs catalog
  *   could not be built, when it could not.
  * @property {Array<{package: string, code: string, severity: 'warning'|'error', message: string}>|null} [integrationIssues]
- * @property {Array<{spec: string, error: string}>|null} [autolinkFailures]
- *   installed dependencies whose integration manifest could not be loaded
  *   Combined project-level integration issues, including cross-package template replacement warnings.
  * @property {Error|null} [configError] - Error thrown while resolving the config
  *   path (e.g. multiple config files present), surfaced by checkConfig as a FAIL.
@@ -423,9 +417,6 @@ export function checkImplicitIntegrations(ctx) {
   const implicit = ctx.integrations.filter(
     integration => integration.__autolinked,
   );
-  // A dependency whose manifest cannot be loaded leaves no loaded record, so
-  // without this line doctor would say no dependency ships a manifest at all.
-  const unreadable = describeUnreadableManifests(ctx.autolinkFailures ?? []);
 
   if (implicit.length === 0) {
     return {
@@ -433,12 +424,9 @@ export function checkImplicitIntegrations(ctx) {
       label,
       status: 'info',
       message:
-        (ctx.integrations.length > 0
+        ctx.integrations.length > 0
           ? 'None — every loaded integration is named in astryx.config.'
-          : unreadable
-            ? 'None loaded.'
-            : 'None — no installed dependency ships an astryx.integration.* manifest.') +
-        unreadable,
+          : 'None — no installed dependency ships an astryx.integration.* manifest.',
     };
   }
 
@@ -451,25 +439,11 @@ export function checkImplicitIntegrations(ctx) {
       integration.__spec && integration.__spec !== integration.name
         ? ` (declared as "${integration.__spec}")`
         : '';
-    // A declared root counts only when it exists: the manifest's keys are a
-    // claim, and `integration-issues` reports the ones that are not true.
-    const declared = ['components', 'templates', 'themes', 'docs', 'codemods'].filter(
+    const roots = ['components', 'templates', 'themes', 'docs', 'codemods'].filter(
       root => integration[/** @type {'components'} */ (root)],
     );
-    const missing = declared.filter(root => {
-      const dir = integration[/** @type {'components'} */ (root)];
-      if (typeof dir !== 'string') return false;
-      const base =
-        typeof integration.__packageDir === 'string'
-          ? integration.__packageDir
-          : (ctx.cwd ?? process.cwd());
-      return !fs.existsSync(path.isAbsolute(dir) ? dir : path.resolve(base, dir));
-    });
-    const roots = declared.filter(root => !missing.includes(root));
     const contributes = roots.length > 0 ? roots.join(', ') : 'nothing';
-    const absent =
-      missing.length > 0 ? ` (declared ${missing.join(', ')} missing on disk)` : '';
-    return `${integration.name}${version}${alias} from ${integration.__dependencyField}, contributing ${contributes}${absent}`;
+    return `${integration.name}${version}${alias} from ${integration.__dependencyField}, contributing ${contributes}`;
   });
 
   const plural = implicit.length === 1 ? '' : 's';
@@ -479,8 +453,7 @@ export function checkImplicitIntegrations(ctx) {
     status: 'info',
     message:
       `${implicit.length} integration${plural} loaded from installed ` +
-      `dependencies with no astryx.config entry: ${described.join('; ')}.` +
-      unreadable,
+      `dependencies with no astryx.config entry: ${described.join('; ')}.`,
     fix:
       'Nothing to fix. Keep these dependencies installed. The CLI links them ' +
       'from package.json, so an unused-dependency check that looks only for ' +
@@ -489,30 +462,6 @@ export function checkImplicitIntegrations(ctx) {
   };
 }
 
-/**
- * The sentence `implicit-integrations` adds for dependencies whose manifest
- * could not be loaded, or '' when there are none. Still informational: the
- * package is a dependency's own bug, which `doctor integration validate`
- * diagnoses, but doctor must not report it as absent.
- * @param {Array<{spec: string, error: string}>} failures
- * @returns {string}
- */
-function describeUnreadableManifests(failures) {
-  if (failures.length === 0) return '';
-  const one = failures.length === 1;
-  const listed = failures
-    .map(({spec, error}) => {
-      const reason = String(error).split('\n')[0].slice(0, 160);
-      return `${spec} (${reason})`;
-    })
-    .join('; ');
-  return (
-    ` ${failures.length} installed ${one ? 'dependency ships' : 'dependencies ship'} ` +
-    `an astryx.integration.* manifest that could not be loaded, so ${one ? 'it contributes' : 'they contribute'} ` +
-    `nothing: ${listed}. Run \`astryx doctor integration validate <package>\` for details.`
-  );
-}
-
 /**
  * Check 7 — agent docs exist and contain the Astryx section markers.
  * @param {DoctorContext} ctx
@@ -789,26 +738,12 @@ export function checkProviderIdentity(ctx) {
     integration =>
       integration.providerId != null && integration.__loadError == null,
   ).length;
-  // An integration that could not be read has no provider ID to check, so the
-  // count above is not a complete survey. Say so instead of counting silently.
-  const unread = ctx.integrations.filter(
-    integration => integration.__loadError != null,
-  ).length;
-  const unreadNote =
-    unread === 0
-      ? ''
-      : unread === 1
-        ? ' 1 loaded integration could not be read, so its provider ID is unknown.'
-        : ` ${unread} loaded integrations could not be read, so their provider IDs are unknown.`;
   if (count === 0) {
     return {
       id,
       label,
       status: 'info',
-      message:
-        (unread === 0
-          ? 'None — no loaded integration has a provider identity.'
-          : 'No readable integration has a provider identity.') + unreadNote,
+      message: 'None — no loaded integration has a provider identity.',
     };
   }
   return {
@@ -816,10 +751,9 @@ export function checkProviderIdentity(ctx) {
     label,
     status: 'pass',
     message:
-      (count === 1
+      count === 1
         ? '1 loaded integration has its own provider ID.'
-        : `${count} loaded integrations each have their own provider ID.`) +
-      unreadNote,
+        : `${count} loaded integrations each have their own provider ID.`,
   };
 }
 
@@ -1264,25 +1198,11 @@ export async function runChecks(options = {}) {
   let docsCatalogError = null;
   /** @type {Array<{package: string, code: string, severity: 'warning'|'error', message: string}>|null} */
   let integrationIssues = null;
-  /** @type {Array<{spec: string, error: string}>|null} */
-  let autolinkFailures = null;
   try {
     const project = await Project.load(cwd);
     configTheme =
       /** @type {{theme?: string}} */ (project.config ?? {}).theme ?? null;
     integrations = project.loadedIntegrations;
-    // An installed dependency whose manifest cannot be loaded is kept out of
-    // loadedIntegrations on purpose. The provider ledger still records it.
-    autolinkFailures = [...providerLedgerOf(project).values()]
-      .filter(
-        entry =>
-          entry.outcome === 'load-failed' &&
-          entry.candidate.source === 'autolinked',
-      )
-      .map(entry => ({
-        spec: entry.candidate.spec ?? entry.label,
-        error: entry.error ?? 'its manifest could not be loaded',
-      }));
     try {
       docsCatalog = await project.docs();
       docsCatalogIssues = (await project.issues()).filter(
@@ -1309,7 +1229,6 @@ export async function runChecks(options = {}) {
     docsCatalogIssues,
     docsCatalogError,
     integrationIssues,
-    autolinkFailures,
     configError,
   };