@astryxdesign/cli 0.6.4 → 0.6.5-canary.031021b

package/api/discover/_catalog-view.d.mts

@@ -0,0 +1,115 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * @typedef {import('./_adapter.mjs').InstalledPackage} InstalledPackage
+ * @typedef {import('./_adapter.mjs').CatalogResult} CatalogResult
+ * @typedef {CatalogResult['packages'][number]} CatalogPackage
+ * @typedef {import('../../authoring/discover/type').DiscoverKind} DiscoverKind
+ */
+/**
+ * An item search looks through. `kind: 'package'` is a package itself.
+ * @typedef {object} SearchItem
+ * @property {string} package
+ * @property {DiscoverKind | 'package'} kind
+ * @property {string} name
+ * @property {boolean} installed
+ * @property {string} [title]
+ * @property {string} [summary]
+ * @property {string[]} [keywords]
+ * @property {string} [description]
+ */
+/**
+ * Group a version's contributions into the entry fields, one list per kind.
+ * `components` is always present, like on an installed entry.
+ * @param {CatalogPackage['contributions']} contributions
+ * @returns {Record<string, string[]>}
+ */
+export function kindLists(contributions: CatalogPackage["contributions"]): Record<string, string[]>;
+/**
+ * Whether an entry adds at least one item of `kind`.
+ * @param {Record<string, unknown>} entry
+ * @param {DiscoverKind} kind
+ * @returns {boolean}
+ */
+export function hasKind(entry: Record<string, unknown>, kind: DiscoverKind): boolean;
+/**
+ * Where a catalog package stands against the project.
+ * @param {CatalogPackage} pkg
+ * @param {Set<string>} installedNames
+ * @param {Set<string>} declared
+ * @returns {{state: 'installed' | 'declared' | 'alias' | 'available', installedAs?: string}}
+ */
+export function catalogState(pkg: CatalogPackage, installedNames: Set<string>, declared: Set<string>): {
+    state: "installed" | "declared" | "alias" | "available";
+    installedAs?: string;
+};
+/**
+ * The version a catalog package shows by default.
+ * @param {CatalogPackage} pkg
+ * @returns {string | undefined}
+ */
+export function defaultVersion(pkg: CatalogPackage): string | undefined;
+/**
+ * Project a catalog package into the entry shape installed packages use.
+ * @param {CatalogPackage} pkg
+ * @param {string | undefined} version
+ */
+export function catalogEntry(pkg: CatalogPackage, version: string | undefined): {
+    description?: string | undefined;
+    version?: string | undefined;
+    name: string;
+    category: string;
+    components: string[];
+};
+/**
+ * What the project could add: every catalog package it does not have, once per
+ * integration (the first name a source lists), never an alias of one it has.
+ * @param {CatalogResult} catalog
+ * @param {InstalledPackage[]} installed
+ * @param {Set<string>} declared
+ */
+export function availableEntries(catalog: CatalogResult, installed: InstalledPackage[], declared: Set<string>): {
+    source: string;
+    aliases?: string[] | undefined;
+    description?: string | undefined;
+    version?: string | undefined;
+    name: string;
+    components: string[];
+}[];
+/**
+ * Installed packages with the latest release a source knows for each.
+ * @param {InstalledPackage[]} installed
+ * @param {CatalogResult} catalog
+ * @returns {Array<InstalledPackage & {latest?: string}>}
+ */
+export function withLatest(installed: InstalledPackage[], catalog: CatalogResult): Array<InstalledPackage & {
+    latest?: string;
+}>;
+/**
+ * Everything search looks through besides installed components (which the
+ * search leaf keeps resolving the way it always has): installed packages and
+ * their other items, and every package the project could add with its items.
+ * @param {InstalledPackage[]} installed
+ * @param {CatalogResult} catalog
+ * @param {Set<string>} declared
+ * @returns {SearchItem[]}
+ */
+export function searchItems(installed: InstalledPackage[], catalog: CatalogResult, declared: Set<string>): SearchItem[];
+export type InstalledPackage = import("./_adapter.mjs").InstalledPackage;
+export type CatalogResult = import("./_adapter.mjs").CatalogResult;
+export type CatalogPackage = CatalogResult["packages"][number];
+export type DiscoverKind = import("../../authoring/discover/type").DiscoverKind;
+/**
+ * An item search looks through. `kind: 'package'` is a package itself.
+ */
+export type SearchItem = {
+    package: string;
+    kind: DiscoverKind | "package";
+    name: string;
+    installed: boolean;
+    title?: string | undefined;
+    summary?: string | undefined;
+    keywords?: string[] | undefined;
+    description?: string | undefined;
+};

package/api/discover/_catalog-view.mjs

@@ -0,0 +1,203 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Pure views over discover sources' catalogs: which catalog packages the
+ * project already has, what it could add, and the items search looks through.
+ * No I/O; the adapter supplies every input.
+ *
+ * @position api/discover — shared by the list, detail, item, and search leaves.
+ */
+
+import {KIND_FIELDS} from './_adapter.mjs';
+
+/**
+ * @typedef {import('./_adapter.mjs').InstalledPackage} InstalledPackage
+ * @typedef {import('./_adapter.mjs').CatalogResult} CatalogResult
+ * @typedef {CatalogResult['packages'][number]} CatalogPackage
+ * @typedef {import('../../authoring/discover/type').DiscoverKind} DiscoverKind
+ */
+
+/**
+ * An item search looks through. `kind: 'package'` is a package itself.
+ * @typedef {object} SearchItem
+ * @property {string} package
+ * @property {DiscoverKind | 'package'} kind
+ * @property {string} name
+ * @property {boolean} installed
+ * @property {string} [title]
+ * @property {string} [summary]
+ * @property {string[]} [keywords]
+ * @property {string} [description]
+ */
+
+/**
+ * Group a version's contributions into the entry fields, one list per kind.
+ * `components` is always present, like on an installed entry.
+ * @param {CatalogPackage['contributions']} contributions
+ * @returns {Record<string, string[]>}
+ */
+export function kindLists(contributions) {
+  /** @type {Record<string, string[]>} */
+  const lists = {components: []};
+  for (const [kind, field] of KIND_FIELDS) {
+    const names = contributions.filter(c => c.kind === kind).map(c => c.name);
+    if (names.length > 0 || field === 'components') lists[field] = names;
+  }
+  return lists;
+}
+
+/**
+ * Whether an entry adds at least one item of `kind`.
+ * @param {Record<string, unknown>} entry
+ * @param {DiscoverKind} kind
+ * @returns {boolean}
+ */
+export function hasKind(entry, kind) {
+  const field = KIND_FIELDS.find(([k]) => k === kind)?.[1];
+  const values = field == null ? undefined : entry[field];
+  return Array.isArray(values) && values.length > 0;
+}
+
+/**
+ * Where a catalog package stands against the project.
+ * @param {CatalogPackage} pkg
+ * @param {Set<string>} installedNames
+ * @param {Set<string>} declared
+ * @returns {{state: 'installed' | 'declared' | 'alias' | 'available', installedAs?: string}}
+ */
+export function catalogState(pkg, installedNames, declared) {
+  if (installedNames.has(pkg.package)) return {state: 'installed'};
+  if (declared.has(pkg.package)) return {state: 'declared'};
+  const installedAs = pkg.aliases.find(
+    name => installedNames.has(name) || declared.has(name),
+  );
+  if (installedAs != null) return {state: 'alias', installedAs};
+  return {state: 'available'};
+}
+
+/**
+ * The version a catalog package shows by default.
+ * @param {CatalogPackage} pkg
+ * @returns {string | undefined}
+ */
+export function defaultVersion(pkg) {
+  return pkg.latest ?? pkg.versions[0]?.version;
+}
+
+/**
+ * Project a catalog package into the entry shape installed packages use.
+ * @param {CatalogPackage} pkg
+ * @param {string | undefined} version
+ */
+export function catalogEntry(pkg, version) {
+  const {components, ...others} = kindLists(pkg.contributions);
+  return {
+    name: pkg.package,
+    category: pkg.package,
+    components,
+    ...(version ? {version} : {}),
+    ...(pkg.description ? {description: pkg.description} : {}),
+    ...others,
+  };
+}
+
+/**
+ * What the project could add: every catalog package it does not have, once per
+ * integration (the first name a source lists), never an alias of one it has.
+ * @param {CatalogResult} catalog
+ * @param {InstalledPackage[]} installed
+ * @param {Set<string>} declared
+ */
+export function availableEntries(catalog, installed, declared) {
+  const installedNames = new Set(installed.map(p => p.name));
+  /** @type {Set<string>} */
+  const integrations = new Set();
+  const entries = [];
+  for (const pkg of catalog.packages) {
+    if (catalogState(pkg, installedNames, declared).state !== 'available')
+      continue;
+    if (integrations.has(pkg.integration)) continue;
+    integrations.add(pkg.integration);
+    const version = defaultVersion(pkg);
+    const {category: _category, ...entry} = catalogEntry(pkg, version);
+    entries.push({
+      ...entry,
+      ...(pkg.aliases.length > 0 ? {aliases: pkg.aliases} : {}),
+      source: pkg.source,
+    });
+  }
+  return entries;
+}
+
+/**
+ * Installed packages with the latest release a source knows for each.
+ * @param {InstalledPackage[]} installed
+ * @param {CatalogResult} catalog
+ * @returns {Array<InstalledPackage & {latest?: string}>}
+ */
+export function withLatest(installed, catalog) {
+  const byName = new Map(catalog.packages.map(p => [p.package, p]));
+  return installed.map(pkg => {
+    const latest = byName.get(pkg.name)?.latest;
+    return latest ? {...pkg, latest} : pkg;
+  });
+}
+
+/**
+ * Everything search looks through besides installed components (which the
+ * search leaf keeps resolving the way it always has): installed packages and
+ * their other items, and every package the project could add with its items.
+ * @param {InstalledPackage[]} installed
+ * @param {CatalogResult} catalog
+ * @param {Set<string>} declared
+ * @returns {SearchItem[]}
+ */
+export function searchItems(installed, catalog, declared) {
+  /** @type {SearchItem[]} */
+  const items = [];
+  for (const pkg of installed) {
+    items.push({
+      package: pkg.name,
+      kind: 'package',
+      name: pkg.name,
+      installed: true,
+      ...(pkg.description ? {description: pkg.description} : {}),
+    });
+    for (const [kind, field] of KIND_FIELDS) {
+      if (kind === 'component') continue;
+      const names = /** @type {Record<string, unknown>} */ (pkg)[field];
+      if (!Array.isArray(names)) continue;
+      for (const name of names) {
+        items.push({package: pkg.name, kind, name, installed: true});
+      }
+    }
+  }
+  const installedNames = new Set(installed.map(p => p.name));
+  /** @type {Set<string>} */
+  const integrations = new Set();
+  for (const pkg of catalog.packages) {
+    if (catalogState(pkg, installedNames, declared).state !== 'available')
+      continue;
+    if (integrations.has(pkg.integration)) continue;
+    integrations.add(pkg.integration);
+    items.push({
+      package: pkg.package,
+      kind: 'package',
+      name: pkg.package,
+      installed: false,
+      ...(pkg.description ? {description: pkg.description} : {}),
+    });
+    for (const c of pkg.contributions) {
+      items.push({
+        package: pkg.package,
+        kind: c.kind,
+        name: c.name,
+        installed: false,
+        ...(c.title ? {title: c.title} : {}),
+        ...(c.summary ? {summary: c.summary} : {}),
+        ...(c.keywords ? {keywords: c.keywords} : {}),
+      });
+    }
+  }
+  return items;
+}

package/api/discover/_catalog-view.test.mjs

@@ -0,0 +1,128 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Tests for the pure views over discover sources' catalogs.
+ */
+
+import {describe, expect, it} from 'vitest';
+import {
+  availableEntries,
+  catalogState,
+  kindLists,
+  searchItems,
+  withLatest,
+} from './_catalog-view.mjs';
+
+/**
+ * @param {string} name
+ * @param {string} integration
+ * @param {object} [extra]
+ * @returns {any}
+ */
+function entry(name, integration, extra = {}) {
+  return {
+    package: name,
+    integration,
+    aliases: [],
+    latest: '1.0.0',
+    versions: [],
+    contributions: [{kind: 'component', name: 'A'}],
+    source: 'S',
+    ...extra,
+  };
+}
+
+const CATALOG = {
+  sources: [],
+  packages: [
+    entry('@acme/ui', 'acme-ui', {aliases: ['@acme/ui-classic']}),
+    entry('@acme/ui-classic', 'acme-ui', {aliases: ['@acme/ui']}),
+    entry('@acme/charts', 'charts', {
+      latest: '2.0.0',
+      contributions: [{kind: 'theme', name: 'ocean'}],
+    }),
+  ],
+};
+
+/** @param {string} name @returns {any} */
+const installed = name => ({name, category: name, components: []});
+
+describe('availableEntries', () => {
+  it('offers each integration once, under the first name a source lists', () => {
+    expect(
+      availableEntries(CATALOG, [], new Set()).map(e => [e.name, e.aliases]),
+    ).toEqual([
+      ['@acme/ui', ['@acme/ui-classic']],
+      ['@acme/charts', undefined],
+    ]);
+  });
+
+  it('never offers an integration the project has under another name', () => {
+    expect(
+      availableEntries(CATALOG, [installed('@acme/ui-classic')], new Set()).map(
+        e => e.name,
+      ),
+    ).toEqual(['@acme/charts']);
+  });
+
+  it('does not offer a package the project declares, even when it did not load', () => {
+    expect(
+      availableEntries(CATALOG, [], new Set(['@acme/charts'])).map(e => e.name),
+    ).toEqual(['@acme/ui']);
+  });
+
+  it('describes an entry the way an installed one is described', () => {
+    expect(availableEntries(CATALOG, [], new Set())[1]).toEqual({
+      name: '@acme/charts',
+      components: [],
+      version: '2.0.0',
+      themes: ['ocean'],
+      source: 'S',
+    });
+  });
+});
+
+describe('catalogState', () => {
+  it('names the package the project has instead', () => {
+    expect(
+      catalogState(CATALOG.packages[0], new Set(['@acme/ui-classic']), new Set()),
+    ).toEqual({state: 'alias', installedAs: '@acme/ui-classic'});
+  });
+});
+
+describe('withLatest', () => {
+  it('adds the latest release a source knows to an installed package', () => {
+    expect(withLatest([installed('@acme/charts')], CATALOG)[0]).toMatchObject({
+      latest: '2.0.0',
+    });
+  });
+});
+
+describe('kindLists', () => {
+  it('groups items by kind, always with components', () => {
+    expect(
+      kindLists([
+        {kind: 'theme', name: 'ocean'},
+        {kind: 'component', name: 'A'},
+      ]),
+    ).toEqual({components: ['A'], themes: ['ocean']});
+  });
+});
+
+describe('searchItems', () => {
+  it('covers installed packages and their other items, then what could be added', () => {
+    const items = searchItems(
+      [{...installed('@acme/widgets'), templates: ['pages/Home']}],
+      CATALOG,
+      new Set(),
+    );
+    expect(items.map(i => [i.package, i.kind, i.name, i.installed])).toEqual([
+      ['@acme/widgets', 'package', '@acme/widgets', true],
+      ['@acme/widgets', 'template', 'pages/Home', true],
+      ['@acme/ui', 'package', '@acme/ui', false],
+      ['@acme/ui', 'component', 'A', false],
+      ['@acme/charts', 'package', '@acme/charts', false],
+      ['@acme/charts', 'theme', 'ocean', false],
+    ]);
+  });
+});

package/api/discover/detail/detail.d.mts

@@ -2,12 +2,24 @@
 // DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
 
 /**
- * Build the discover.detail response for a scoped package name. Throws
- * AstryxError (ERR_UNKNOWN_PACKAGE) — with the available packages as
- * suggestions — when no package matches.
+ * Build the discover.detail response for one package. The project's installed
+ * copy describes itself; any other version is described by its source. For a
+ * package the project does not have, `install` is the package-manager command
+ * that adds it — printed, never run.
  *
- * @param {import('../_package-scanner.mjs').ScannedPackage[]} packages
- * @param {string} query scoped package name, e.g. `@scope/name`
+ * @param {import('../_adapter.mjs').InstalledPackage[]} packages
+ * @param {string} name package name, e.g. `@scope/name`
+ * @param {{
+ *   catalog?: import('../_catalog-view.mjs').CatalogPackage,
+ *   version?: string,
+ *   add?: (name: string, version?: string) => string,
+ *   installedAs?: string,
+ * }} [options]
  * @returns {import('../discover.type.mjs').DiscoverDetailResponse}
  */
-export function detail(packages: import("../_package-scanner.mjs").ScannedPackage[], query: string): import("../discover.type.mjs").DiscoverDetailResponse;
+export function detail(packages: import("../_adapter.mjs").InstalledPackage[], name: string, options?: {
+    catalog?: import("../_catalog-view.mjs").CatalogPackage;
+    version?: string;
+    add?: (name: string, version?: string) => string;
+    installedAs?: string;
+}): import("../discover.type.mjs").DiscoverDetailResponse;

package/api/discover/detail/detail.mjs

@@ -1,33 +1,87 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
 /**
- * @file discover.detail leaf — browse one external package (@scope/name).
+ * @file discover.detail leaf — one package: what it adds, and, when a discover
+ * source knows it, every version and the latest one.
  *
- * @position api/discover/detail — pure projection over the packages resolved by
- *   ../_adapter; throws AstryxError (ERR_UNKNOWN_PACKAGE) for an unknown scope.
+ * @position api/discover/detail — pure projection over the packages and catalog
+ *   entry resolved by ../_adapter; throws AstryxError (ERR_UNKNOWN_PACKAGE) for
+ *   a package neither the project nor any source knows.
  */
 
 import {toEntry} from '../_adapter.mjs';
+import {catalogEntry, defaultVersion} from '../_catalog-view.mjs';
 import {AstryxError} from '../../error.mjs';
 import {ERROR_CODES} from '../../../foundation/response/error-codes.mjs';
 
 /**
- * Build the discover.detail response for a scoped package name. Throws
- * AstryxError (ERR_UNKNOWN_PACKAGE) — with the available packages as
- * suggestions — when no package matches.
+ * Build the discover.detail response for one package. The project's installed
+ * copy describes itself; any other version is described by its source. For a
+ * package the project does not have, `install` is the package-manager command
+ * that adds it — printed, never run.
  *
- * @param {import('../_package-scanner.mjs').ScannedPackage[]} packages
- * @param {string} query scoped package name, e.g. `@scope/name`
+ * @param {import('../_adapter.mjs').InstalledPackage[]} packages
+ * @param {string} name package name, e.g. `@scope/name`
+ * @param {{
+ *   catalog?: import('../_catalog-view.mjs').CatalogPackage,
+ *   version?: string,
+ *   add?: (name: string, version?: string) => string,
+ *   installedAs?: string,
+ * }} [options]
  * @returns {import('../discover.type.mjs').DiscoverDetailResponse}
  */
-export function detail(packages, query) {
-  const pkg = packages.find(p => p.name === query);
-  if (!pkg) {
+export function detail(packages, name, options = {}) {
+  const {catalog, version, add, installedAs} = options;
+  const pkg = packages.find(p => p.name === name);
+  if (!pkg && !catalog) {
     throw new AstryxError(
-      `Package "${query}" not found`,
+      `Package "${name}" not found`,
       packages.map(p => ({name: p.name, reason: 'available package'})),
       ERROR_CODES.ERR_UNKNOWN_PACKAGE,
     );
   }
-  return {type: 'discover.detail', data: toEntry(pkg)};
+
+  const known = new Set([
+    ...(catalog?.versions.map(v => v.version) ?? []),
+    ...(pkg?.version ? [pkg.version] : []),
+  ]);
+  if (version && !known.has(version)) {
+    const releases = catalog?.versions.filter(v => !v.prerelease) ?? [];
+    throw new AstryxError(
+      `Version "${version}" of ${name} not found`,
+      (releases.length > 0 ? releases.map(v => v.version) : [...known])
+        .slice(0, 5)
+        .map(v => ({name: `${name}@${v}`, reason: 'published version'})),
+      ERROR_CODES.ERR_NOT_FOUND,
+    );
+  }
+
+  const local = pkg != null && (!version || version === pkg.version);
+  /** @type {Record<string, unknown>} */
+  const data = local
+    ? {...toEntry(pkg), installed: true}
+    : {
+        ...catalogEntry(
+          /** @type {NonNullable<typeof catalog>} */ (catalog),
+          version ?? defaultVersion(/** @type {NonNullable<typeof catalog>} */ (catalog)),
+        ),
+        installed: pkg != null,
+        ...(pkg?.version ? {installedVersion: pkg.version} : {}),
+      };
+  if (catalog) {
+    if (catalog.latest) data.latest = catalog.latest;
+    if (catalog.aliases.length > 0) data.aliases = catalog.aliases;
+    data.source = catalog.source;
+  }
+  if (!pkg) {
+    if (installedAs) data.installedAs = installedAs;
+    else if (add) data.install = add(name, version);
+  }
+  if (catalog) data.versions = catalog.versions;
+  return {
+    type: 'discover.detail',
+    data: /** @type {import('../discover.type.mjs').DiscoverDetailResponse['data']} */ (
+      data
+    ),
+  };
 }

package/api/discover/detail/detail.test.mjs

@@ -36,6 +36,7 @@ describe('discover.detail leaf', () => {
       category: '@acme/widgets',
       components: ['Alpha', 'Beta'],
       version: '1.2.3',
+      installed: true,
     });
   });
 
@@ -55,3 +56,87 @@ describe('discover.detail leaf', () => {
     ]);
   });
 });
+
+describe('discover.detail leaf with a discover source', () => {
+  /** @type {any} */
+  const catalog = {
+    package: '@acme/charts',
+    integration: 'acme-charts',
+    aliases: ['@acme/charts-legacy'],
+    latest: '2.0.0',
+    source: 'Acme',
+    versions: [
+      {version: '2.1.0-beta.1', publishedAt: '2026-09-30T00:00:00.000Z', prerelease: true, status: 'ok'},
+      {version: '2.0.0', publishedAt: '2026-09-20T00:00:00.000Z', prerelease: false, status: 'ok'},
+      {version: '1.0.0', publishedAt: null, prerelease: false, status: 'manifest_load_error'},
+    ],
+    contributions: [
+      {kind: 'component', name: 'Chart'},
+      {kind: 'template', name: 'pages/Report'},
+    ],
+  };
+  /** @param {string} name @param {string} [version] */
+  const add = (name, version) => `pnpm add ${version ? `${name}@${version}` : name}`;
+
+  it('describes a package the project does not have, with the command that adds it', () => {
+    expect(detail(PACKAGES, '@acme/charts', {catalog, add}).data).toEqual({
+      name: '@acme/charts',
+      category: '@acme/charts',
+      components: ['Chart'],
+      version: '2.0.0',
+      templates: ['pages/Report'],
+      installed: false,
+      latest: '2.0.0',
+      aliases: ['@acme/charts-legacy'],
+      source: 'Acme',
+      install: 'pnpm add @acme/charts',
+      versions: catalog.versions,
+    });
+  });
+
+  it('describes any version, prereleases included', () => {
+    const {data} = detail(PACKAGES, '@acme/charts', {catalog, add, version: '2.1.0-beta.1'});
+    expect(data.version).toBe('2.1.0-beta.1');
+    expect(data.install).toBe('pnpm add @acme/charts@2.1.0-beta.1');
+  });
+
+  it('refuses a version that was never published, and suggests releases', () => {
+    let err;
+    try {
+      detail(PACKAGES, '@acme/charts', {catalog, add, version: '3.0.0'});
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(AstryxError);
+    expect(err.code).toBe('ERR_NOT_FOUND');
+    expect(err.suggestions.map(s => s.name)).toEqual([
+      '@acme/charts@2.0.0',
+      '@acme/charts@1.0.0',
+    ]);
+  });
+
+  it('names the package the project has instead of offering an alias', () => {
+    const {data} = detail(PACKAGES, '@acme/charts', {
+      catalog,
+      add,
+      installedAs: '@acme/charts-legacy',
+    });
+    expect(data.installedAs).toBe('@acme/charts-legacy');
+    expect(data).not.toHaveProperty('install');
+  });
+
+  it("keeps describing the installed copy from the project, with the source's versions", () => {
+    const {data} = detail(PACKAGES, '@acme/widgets', {
+      catalog: {...catalog, package: '@acme/widgets', latest: '1.3.0'},
+      add,
+    });
+    expect(data).toMatchObject({
+      name: '@acme/widgets',
+      components: ['Alpha', 'Beta'],
+      version: '1.2.3',
+      installed: true,
+      latest: '1.3.0',
+    });
+    expect(data).not.toHaveProperty('install');
+  });
+});