Function resolveItemWithDependencies

packages/cli/src/registry/resolver.ts:114–178

(
  name: string,
  options: ResolveOptions = {},
)

 * parallel sibling fetches only if graph depth ever becomes a real cost.
 */
export async function resolveItemWithDependencies(
  name: string,
  options: ResolveOptions = {},
): Promise<RegistryItem[]> {
  const entries = await listRegistryItems(undefined, options);
  const entry = entries.find((e) => e.name === name);
  if (!entry) {
    const available = entries.map((e) => e.name).join(", ");
    throw new Error(
      available.length > 0
        ? `Item "${name}" not found in registry. Available: ${available}`
        : `Item "${name}" not found — registry unreachable or empty.`,
    );
  }

  const entryByName = new Map(entries.map((e) => [e.name, e]));
  const visiting = new Set<string>();
  const visited = new Set<string>();
  const ordered: RegistryItem[] = [];
  const itemCache = new Map<string, Promise<RegistryItem>>();

  // `async` so the missing-dependency path surfaces as a promise rejection
  // rather than a synchronous throw, keeping the control flow consistent with
  // the `Promise<RegistryItem>` return type. The body has no `await`, so the
  // cache is still populated synchronously on first request (dedup intact).
  const getItem = async (itemName: string): Promise<RegistryItem> => {
    const existing = itemCache.get(itemName);
    if (existing) return existing;

    const registryEntry = entryByName.get(itemName);
    if (!registryEntry) {
      const available = entries.map((e) => e.name).join(", ");
      throw new Error(
        available.length > 0
          ? `Dependency "${itemName}" not found in registry. Available: ${available}`
          : `Dependency "${itemName}" not found — registry unreachable or empty.`,
      );
    }

    const pending = fetchItemManifest(registryEntry.name, registryEntry.type, options.baseUrl);
    itemCache.set(itemName, pending);
    return pending;
  };

  const visit = async (itemName: string, path: string[]): Promise<void> => {
    if (visited.has(itemName)) return;
    if (visiting.has(itemName)) {
      const cycleStart = path.indexOf(itemName);
      const cyclePath = [...path.slice(cycleStart), itemName].join(" -> ");
      throw new Error(`Circular registryDependencies detected: ${cyclePath}`);
    }

    visiting.add(itemName);
    const item = await getItem(itemName);
    for (const dep of item.registryDependencies ?? []) {
      await visit(dep, [...path, itemName]);
    }
    visiting.delete(itemName);