create-next-hydra 0.2.1 → 0.4.1

package/dist/composition/catalog.js

@@ -1,313 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { getRegistriesConfig, getRegistryItems, loadRegistry, } from "shadcn/registry";
-import { pathExists } from "../fs-utils.js";
-import { CompositionValidationError } from "./errors.js";
-import { isManagedApplicationSource, resolveRegistryTarget, resolveWorkspacePath, } from "./paths.js";
-import { formatZodError, NEXT_HYDRA_SELECTION_SCHEMA_URL, selectionDefinitionSchema, } from "./schema.js";
-const GITHUB_HOMEPAGE_PATTERN = /^https:\/\/github\.com\/([^/]+\/[^/]+?)(?:\.git)?\/?$/;
-const SHADCN_REGISTRY_ITEM_SCHEMA_URL = "https://ui.shadcn.com/schema/registry-item.json";
-const OFFICIAL_REFERENCES = {
-    commercetools: "next-hydra/commerce/commercetools",
-    contentstack: "next-hydra/cms/contentstack",
-    drupal: "next-hydra/cms/drupal",
-    standard: "next-hydra/preset/standard",
-    workos: "next-hydra/auth/workos",
-};
-const OFFICIAL_ITEM_NAMES = [
-    "auth-workos",
-    "cms-contentstack",
-    "cms-drupal",
-    "commerce-commercetools",
-    "drupal",
-    "next-hydra-standard",
-];
-function restoreFetchedSelectionSchema(item) {
-    // ShadCN assigns its registry-item schema to every resolved artifact,
-    // including artifacts authored with the Next Hydra Selection schema.
-    if (item.meta?.nextHydra !== undefined &&
-        item.$schema === SHADCN_REGISTRY_ITEM_SCHEMA_URL) {
-        return { ...item, $schema: NEXT_HYDRA_SELECTION_SCHEMA_URL };
-    }
-    return item;
-}
-function createCatalog(options) {
-    const items = new Map(options.registryItems.map((item) => [item.name, item]));
-    const itemByReference = new Map(options.itemByReference);
-    const selections = [];
-    const issues = [];
-    for (const item of options.registryItems) {
-        itemByReference.set(item.name, item.name);
-        if (options.repository) {
-            itemByReference.set(`${options.repository}/${item.name}`, item.name);
-        }
-    }
-    for (const item of options.registryItems) {
-        const candidate = item.meta?.nextHydra;
-        if (candidate === undefined) {
-            continue;
-        }
-        if (item.$schema !== NEXT_HYDRA_SELECTION_SCHEMA_URL) {
-            issues.push(`${item.name}.$schema must be ${NEXT_HYDRA_SELECTION_SCHEMA_URL}`);
-            continue;
-        }
-        const result = selectionDefinitionSchema.safeParse(candidate);
-        if (!result.success) {
-            issues.push(...formatZodError(result.error).map((issue) => `${item.name}.meta.nextHydra.${issue}`));
-            continue;
-        }
-        selections.push({ ...result.data, itemName: item.name });
-    }
-    const byId = new Map();
-    const byReference = new Map();
-    for (const selection of selections) {
-        const duplicateItemName = byId.get(selection.id)?.itemName;
-        if (duplicateItemName !== undefined) {
-            issues.push(`selection ID ${selection.id} is declared by both ${duplicateItemName} and ${selection.itemName}`);
-            continue;
-        }
-        byId.set(selection.id, selection);
-        byReference.set(selection.itemName, selection);
-        byReference.set(selection.id, selection);
-        itemByReference.set(selection.id, selection.itemName);
-    }
-    for (const [reference, id] of Object.entries(OFFICIAL_REFERENCES)) {
-        const selection = byId.get(id);
-        if (selection) {
-            byReference.set(reference, selection);
-            itemByReference.set(reference, selection.itemName);
-        }
-    }
-    for (const [reference, itemName] of itemByReference) {
-        const selection = selections.find((candidate) => candidate.itemName === itemName);
-        if (selection) {
-            byReference.set(reference, selection);
-        }
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("The source registry contains invalid Next Hydra metadata.", issues);
-    }
-    const managedTargets = [
-        ...new Set(options.registryItems.flatMap((item) => item.files
-            ?.filter((file) => isManagedApplicationSource(file.path, file.target))
-            .map((file) => {
-            if (!file.target) {
-                throw new CompositionValidationError("Managed application files require explicit targets.", [`${item.name}:${file.path} does not declare files[].target`]);
-            }
-            return resolveRegistryTarget(file.target);
-        }) ?? [])),
-    ].sort((left, right) => left.localeCompare(right));
-    return {
-        authoringPaths: options.authoringPaths,
-        byId,
-        byReference,
-        cwd: options.cwd,
-        itemByReference,
-        items,
-        managedTargets,
-        registryConfig: options.registryConfig,
-        registryFile: options.registryFile,
-        repository: options.repository,
-        selections: [...selections].sort((left, right) => left.id.localeCompare(right.id)),
-    };
-}
-function registryDependencyName(catalog, reference) {
-    return catalog.itemByReference.get(reference);
-}
-export function resolveRegistryItemGraph(catalog, entryItems) {
-    const resolved = new Set();
-    const pending = [...entryItems];
-    while (pending.length > 0) {
-        const itemName = pending.pop();
-        if (!itemName || resolved.has(itemName)) {
-            continue;
-        }
-        const item = catalog.items.get(itemName);
-        if (!item) {
-            throw new CompositionValidationError("Missing registry item.", [
-                `${itemName} is not in the source registry`,
-            ]);
-        }
-        resolved.add(itemName);
-        for (const reference of item.registryDependencies ?? []) {
-            const dependency = registryDependencyName(catalog, reference);
-            if (!dependency) {
-                throw new CompositionValidationError("Registry dependency graph is incomplete.", [`${itemName} depends on unresolved item ${reference}`]);
-            }
-            if (!resolved.has(dependency)) {
-                pending.push(dependency);
-            }
-        }
-    }
-    return [...resolved].sort((left, right) => left.localeCompare(right));
-}
-async function resolveRegistryReference(reference, cwd) {
-    if (path.isAbsolute(reference)) {
-        return reference;
-    }
-    const localReference = path.resolve(cwd, reference);
-    return (await pathExists(localReference)) ? localReference : reference;
-}
-export async function fetchRegistryItemGraph(options) {
-    const items = new Map([...(options.items ?? [])].map((item) => [item.name, item]));
-    const itemByReference = new Map(options.itemByReference);
-    const pending = [...new Set(options.references)];
-    const expandedItems = new Set();
-    const fetchedItemNames = new Set();
-    const fetchedItems = new Map();
-    const fetchItems = options.fetchItems ?? getRegistryItems;
-    for (const item of items.values()) {
-        itemByReference.set(item.name, item.name);
-        if (options.repository) {
-            itemByReference.set(`${options.repository}/${item.name}`, item.name);
-        }
-    }
-    while (pending.length > 0) {
-        const reference = pending.shift();
-        if (!reference) {
-            continue;
-        }
-        let itemName = itemByReference.get(reference);
-        if (!itemName) {
-            // oxlint-disable-next-line no-await-in-loop -- Breadth-first discovery reveals each next reference in order.
-            const resolvedReference = await resolveRegistryReference(reference, options.cwd);
-            const [fetchedArtifact] = await fetchItems([resolvedReference], {
-                config: options.config,
-            });
-            if (!fetchedArtifact) {
-                throw new CompositionValidationError("The registry dependency graph is incomplete.", [`${reference} returned no registry item`]);
-            }
-            const artifact = restoreFetchedSelectionSchema(fetchedArtifact);
-            const fetched = fetchedItems.get(artifact.name);
-            const unpinnedReference = reference.split("#", 1)[0] ?? reference;
-            const replacesPinnedRepositoryItem = reference.includes("#") &&
-                options.repository !== undefined &&
-                unpinnedReference === `${options.repository}/${artifact.name}`;
-            const existing = items.get(artifact.name);
-            if ((fetched && !isDeepStrictEqual(fetched, artifact)) ||
-                (existing &&
-                    !isDeepStrictEqual(existing, artifact) &&
-                    !replacesPinnedRepositoryItem)) {
-                throw new CompositionValidationError("Registry item names conflict.", [
-                    `${artifact.name} resolves to different content through ${reference}`,
-                ]);
-            }
-            if (existing &&
-                !isDeepStrictEqual(existing, artifact) &&
-                replacesPinnedRepositoryItem) {
-                expandedItems.delete(artifact.name);
-            }
-            items.set(artifact.name, artifact);
-            fetchedItems.set(artifact.name, artifact);
-            fetchedItemNames.add(artifact.name);
-            itemName = artifact.name;
-            itemByReference.set(reference, itemName);
-            itemByReference.set(resolvedReference, itemName);
-            itemByReference.set(itemName, itemName);
-        }
-        if (expandedItems.has(itemName)) {
-            continue;
-        }
-        const item = items.get(itemName);
-        if (!item) {
-            throw new CompositionValidationError("The registry dependency graph is incomplete.", [`${reference} resolves to missing item ${itemName}`]);
-        }
-        expandedItems.add(itemName);
-        pending.push(...(item.registryDependencies ?? []));
-    }
-    return { fetchedItemNames, itemByReference, items };
-}
-export async function loadSourceRegistryCatalog(cwd, registryFile = "registry.json") {
-    const resolvedCwd = path.resolve(cwd);
-    const safeRegistryFile = resolveWorkspacePath(registryFile, "source registry file");
-    const registryPath = path.resolve(resolvedCwd, safeRegistryFile);
-    const sourceRegistry = JSON.parse(await readFile(registryPath, "utf-8"));
-    const repository = sourceRegistry.homepage?.match(GITHUB_HOMEPAGE_PATTERN)?.[1];
-    const registry = await loadRegistry({
-        cwd: resolvedCwd,
-        registryFile: safeRegistryFile,
-    });
-    const registryConfig = await getRegistriesConfig(resolvedCwd);
-    const includedRegistries = (sourceRegistry.include ?? []).map((included) => resolveWorkspacePath(included, "source registry include"));
-    const registrySourcePaths = includedRegistries.map((included) => path.posix.join(path.posix.dirname(included), "registry"));
-    return createCatalog({
-        authoringPaths: [
-            safeRegistryFile,
-            ...includedRegistries,
-            ...registrySourcePaths,
-        ].sort((left, right) => left.localeCompare(right)),
-        cwd: resolvedCwd,
-        registryConfig,
-        registryFile: safeRegistryFile,
-        registryItems: registry.items,
-        repository,
-    });
-}
-export async function loadGitHubSourceRegistryCatalog(repository, ref, dependencies = {}) {
-    const suffix = ref ? `#${ref}` : "";
-    const addresses = OFFICIAL_ITEM_NAMES.map((item) => `${repository}/${item}${suffix}`);
-    const fetchedItems = await (dependencies.fetchItems ?? getRegistryItems)(addresses);
-    const registryItems = fetchedItems.map(restoreFetchedSelectionSchema);
-    const registryConfig = await (dependencies.loadRegistryConfig ?? getRegistriesConfig)(process.cwd());
-    const itemByReference = new Map(registryItems.flatMap((item, index) => {
-        const address = addresses[index];
-        return address ? [[address, item.name]] : [];
-    }));
-    return createCatalog({
-        authoringPaths: [],
-        cwd: "",
-        itemByReference,
-        registryConfig,
-        registryFile: `${repository}/registry.json${suffix}`,
-        registryItems,
-        repository,
-    });
-}
-export async function addCatalogReferences(catalog, references, cwd = catalog.cwd || process.cwd()) {
-    const registryConfig = await getRegistriesConfig(cwd);
-    const requestedReferences = [...new Set(references)];
-    const graph = await fetchRegistryItemGraph({
-        config: registryConfig,
-        cwd,
-        itemByReference: catalog.itemByReference,
-        items: catalog.items.values(),
-        references: requestedReferences,
-        repository: catalog.repository,
-    });
-    const current = createCatalog({
-        authoringPaths: catalog.authoringPaths,
-        cwd: catalog.cwd,
-        itemByReference: graph.itemByReference,
-        registryConfig,
-        registryFile: catalog.registryFile,
-        registryItems: [...graph.items.values()],
-        repository: catalog.repository,
-    });
-    for (const reference of requestedReferences) {
-        const itemName = current.itemByReference.get(reference);
-        const selection = itemName ? current.byReference.get(itemName) : undefined;
-        if (!selection) {
-            throw new CompositionValidationError("The requested registry item is not a Next Hydra selection.", [`${reference} does not contain meta.nextHydra`]);
-        }
-        current.byReference.set(reference, selection);
-    }
-    for (const itemName of graph.fetchedItemNames) {
-        const externalSelection = current.byReference.get(itemName);
-        if (externalSelection !== undefined && externalSelection.assets.length > 0) {
-            throw new CompositionValidationError("External selections cannot declare separate binary assets in v1.", [
-                `${externalSelection.id} must be included by the starter source registry; separately fetched binary assets are not supported`,
-            ]);
-        }
-    }
-    return current;
-}
-export function resolveCatalogSelection(catalog, reference) {
-    const selection = catalog.byReference.get(reference);
-    if (!selection) {
-        throw new CompositionValidationError("Unknown composition selection.", [
-            `${reference} is not present in ${catalog.registryFile}`,
-        ]);
-    }
-    return selection;
-}

package/dist/composition/errors.d.ts

@@ -1,5 +0,0 @@
-export declare class CompositionValidationError extends Error {
-    readonly issues: string[];
-    constructor(message: string, issues: string[], options?: ErrorOptions);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/composition/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/composition/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAE1B,YAAY,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,EAOpE;CACF"}

package/dist/composition/errors.js

@@ -1,8 +0,0 @@
-export class CompositionValidationError extends Error {
-    issues;
-    constructor(message, issues, options) {
-        super(`${message}\n${issues.map((issue) => `- ${issue}`).join("\n")}`, options);
-        this.name = "CompositionValidationError";
-        this.issues = issues;
-    }
-}

package/dist/composition/format.d.ts

@@ -1,6 +0,0 @@
-import type { CompositionPlan, WorkspaceSelection } from "./types.js";
-export declare function hasCompositionChanges(current: WorkspaceSelection, proposed: WorkspaceSelection): boolean;
-export declare function formatCompositionPreview(current: WorkspaceSelection, proposed: WorkspaceSelection): string;
-export declare function formatCompositionResult(current: WorkspaceSelection, proposed: WorkspaceSelection): string;
-export declare function formatCompositionPlan(plan: CompositionPlan): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/composition/format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/composition/format.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAwCtE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAET;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,CA4BR;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,CAKR;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAuBnE"}

package/dist/composition/format.js

@@ -1,63 +0,0 @@
-import { PROVIDER_SLOTS } from "./types.js";
-const NO_ADD_ONS = "none";
-function formatAddOns(addOns) {
-    return addOns.length > 0 ? [...addOns].sort().join(", ") : NO_ADD_ONS;
-}
-function sameAddOns(current, proposed) {
-    return formatAddOns(current) === formatAddOns(proposed);
-}
-function formatTransition(current, proposed) {
-    return current === proposed
-        ? `${current} (unchanged)`
-        : `${current} -> ${proposed}`;
-}
-function compositionChanges(current, proposed) {
-    const providerChanges = PROVIDER_SLOTS.filter((slot) => current.providers[slot] !== proposed.providers[slot]).map((slot) => `${slot}: ${current.providers[slot]} -> ${proposed.providers[slot]}`);
-    const addOnChanges = sameAddOns(current.addOns, proposed.addOns)
-        ? []
-        : [
-            `add-ons: ${formatAddOns(current.addOns)} -> ${formatAddOns(proposed.addOns)}`,
-        ];
-    return [...providerChanges, ...addOnChanges];
-}
-export function hasCompositionChanges(current, proposed) {
-    return compositionChanges(current, proposed).length > 0;
-}
-export function formatCompositionPreview(current, proposed) {
-    const currentAddOns = formatAddOns(current.addOns);
-    const proposedAddOns = formatAddOns(proposed.addOns);
-    const lines = [
-        "Maintainer workspace composition",
-        "",
-        "Current -> Proposed",
-        "Providers:",
-        ...PROVIDER_SLOTS.map((slot) => `  ${slot}: ${formatTransition(current.providers[slot], proposed.providers[slot])}`),
-        `Add-ons: ${currentAddOns === proposedAddOns ? `${currentAddOns} (unchanged)` : `${currentAddOns} -> ${proposedAddOns}`}`,
-    ];
-    if (hasCompositionChanges(current, proposed)) {
-        lines.push("", "Planned actions:", "  replace managed application files", "  install selected source", "  update package aliases", "  update pnpm patches", "  run pnpm install");
-    }
-    return lines.join("\n");
-}
-export function formatCompositionResult(current, proposed) {
-    const changes = compositionChanges(current, proposed);
-    return changes.length > 0
-        ? `Maintainer workspace composition updated: ${changes.join("; ")}.`
-        : "No composition changes to apply.";
-}
-export function formatCompositionPlan(plan) {
-    const lines = [
-        "Providers:",
-        ...Object.entries(plan.selection.providers).map(([slot, provider]) => `  ${slot}: ${provider}`),
-        `Add-ons: ${plan.selection.addOns.length > 0 ? plan.selection.addOns.join(", ") : "none"}`,
-        "Registry items:",
-        ...plan.registryItems.map((item) => `  ${item}`),
-        "Package entries:",
-        ...plan.packageRequirements.map((requirement) => `  ${requirement.cwd}: ${requirement.name} = ${requirement.specifier}`),
-        "pnpm patches:",
-        ...plan.pnpmPatches.map((patch) => `  ${patch.dependency} -> ${patch.path}`),
-        "Managed application files:",
-        ...plan.managedTargets.map((target) => `  ${target}`),
-    ];
-    return lines.join("\n");
-}

package/dist/composition/install.d.ts

@@ -1,16 +0,0 @@
-import { addRegistryItems } from "shadcn/registry";
-import type { RegistryItem } from "shadcn/schema";
-import type { CompositionPlan, PreparedComposition, SourceRegistryCatalog } from "./types.js";
-type AddRegistryItemsOptions = Omit<NonNullable<Parameters<typeof addRegistryItems>[1]>, "silent">;
-export declare function addRegistryItemsQuietly(items: string[], options: AddRegistryItemsOptions): Promise<void>;
-export declare function prepareComposition(catalog: SourceRegistryCatalog, plan: CompositionPlan): Promise<PreparedComposition>;
-export declare function withPreparedRegistryArtifacts<T>(options: {
-    artifacts: RegistryItem[];
-    entryItems: string[];
-    itemByReference: Map<string, string>;
-    run: (entries: string[]) => Promise<T>;
-}): Promise<T>;
-export declare function validatePackageRequirementTargets(workspaceRoot: string, plan: CompositionPlan, prepared: PreparedComposition, removedTargets?: Iterable<string>): Promise<void>;
-export declare function installPreparedComposition(workspaceRoot: string, prepared: PreparedComposition): Promise<void>;
-export {};
-//# sourceMappingURL=install.d.ts.map

package/dist/composition/install.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/composition/install.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAoB,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAMlD,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAIpB,KAAK,uBAAuB,GAAG,IAAI,CACjC,WAAW,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,EACnD,QAAQ,CACT,CAAC;AA0BF,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAIf;AAgBD,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,mBAAmB,CAAC,CAuC9B;AAWD,wBAAsB,6BAA6B,CAAC,CAAC,EAAE,OAAO,EAAE;IAC9D,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACxC,GAAG,OAAO,CAAC,CAAC,CAAC,CAkDb;AAED,wBAAsB,iCAAiC,CACrD,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,GAAE,QAAQ,CAAC,MAAM,CAAM,GACpC,OAAO,CAAC,IAAI,CAAC,CAmDf;AAED,wBAAsB,0BAA0B,CAC9C,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/dist/composition/install.js

@@ -1,175 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { addRegistryItems, loadRegistryItem } from "shadcn/registry";
-import { pathExists } from "../fs-utils.js";
-import { CompositionValidationError } from "./errors.js";
-import { parsePackageJson, readPackageJson } from "./packages.js";
-import { isManagedApplicationSource, resolveRegistryTarget } from "./paths.js";
-const SHADCN_ENVIRONMENT_HEADING = "Added the following variables to";
-async function suppressShadcnEnvironmentHeading(operation) {
-    const originalWrite = process.stderr.write;
-    process.stderr.write = (...args) => {
-        const [chunk] = args;
-        // ShadCN 4.16.2 emits this Ora heading even when `silent` is enabled.
-        if (String(chunk).includes(SHADCN_ENVIRONMENT_HEADING)) {
-            const callback = args.find((argument) => typeof argument === "function");
-            callback?.();
-            return true;
-        }
-        return Reflect.apply(originalWrite, process.stderr, args);
-    };
-    try {
-        return await operation();
-    }
-    finally {
-        process.stderr.write = originalWrite;
-    }
-}
-export async function addRegistryItemsQuietly(items, options) {
-    await suppressShadcnEnvironmentHeading(async () => {
-        await addRegistryItems(items, { ...options, silent: true });
-    });
-}
-function resolveArtifact(catalog, item) {
-    const resolved = catalog.items.get(item);
-    if (resolved &&
-        (resolved.files ?? []).every((file) => file.content !== undefined)) {
-        return resolved;
-    }
-    return loadRegistryItem(item, {
-        cwd: catalog.cwd,
-        registryFile: catalog.registryFile,
-    });
-}
-export async function prepareComposition(catalog, plan) {
-    const artifacts = await Promise.all([...catalog.items].map(([item]) => resolveArtifact(catalog, item)));
-    const selectedItemNames = new Set(plan.registryItems);
-    const managedFiles = artifacts
-        .filter((artifact) => selectedItemNames.has(artifact.name))
-        .flatMap((artifact) => artifact.files
-        ?.filter((file) => isManagedApplicationSource(file.path, file.target))
-        .map((file) => {
-        if (!(file.target && file.content !== undefined)) {
-            throw new CompositionValidationError("Managed application files require targets and resolved content.", [`${artifact.name}:${file.path} cannot be prepared`]);
-        }
-        return {
-            content: file.content,
-            target: resolveRegistryTarget(file.target),
-        };
-    }) ?? [])
-        .sort((left, right) => left.target.localeCompare(right.target));
-    return {
-        artifacts,
-        assets: await Promise.all(plan.assets.map(async (asset) => ({
-            ...asset,
-            content: await readFile(path.join(catalog.cwd, asset.source)),
-        }))),
-        entryItems: plan.entryItems,
-        itemByReference: new Map(catalog.itemByReference),
-        managedFiles,
-        registryConfig: catalog.registryConfig,
-    };
-}
-function localDependencyName(reference, itemByReference, artifactPaths) {
-    const itemName = itemByReference.get(reference);
-    return itemName && artifactPaths.has(itemName) ? itemName : undefined;
-}
-export async function withPreparedRegistryArtifacts(options) {
-    const artifactDirectory = await mkdtemp(path.join(tmpdir(), "next-hydra-registry-"));
-    try {
-        const artifactPaths = new Map(options.artifacts.map((artifact, index) => [
-            artifact.name,
-            path.join(artifactDirectory, `${index}.json`),
-        ]));
-        await Promise.all(options.artifacts.map(async (artifact) => {
-            const artifactPath = artifactPaths.get(artifact.name);
-            if (!artifactPath) {
-                throw new Error(`Missing prepared registry item ${artifact.name}.`);
-            }
-            const registryDependencies = artifact.registryDependencies?.map((reference) => {
-                const localName = localDependencyName(reference, options.itemByReference, artifactPaths);
-                return ((localName ? artifactPaths.get(localName) : undefined) ??
-                    reference);
-            });
-            await writeFile(artifactPath, `${JSON.stringify({ ...artifact, registryDependencies }, null, 2)}\n`, "utf-8");
-        }));
-        const entries = options.entryItems.map((item) => {
-            const artifactPath = artifactPaths.get(item);
-            if (!artifactPath) {
-                throw new Error(`Missing prepared registry entry ${item}.`);
-            }
-            return artifactPath;
-        });
-        return await options.run(entries);
-    }
-    finally {
-        await rm(artifactDirectory, { force: true, recursive: true });
-    }
-}
-export async function validatePackageRequirementTargets(workspaceRoot, plan, prepared, removedTargets = []) {
-    const selectedItems = new Set(plan.registryItems);
-    const removed = new Set(removedTargets);
-    const prospectiveManifests = new Map();
-    for (const artifact of prepared.artifacts) {
-        if (!selectedItems.has(artifact.name)) {
-            continue;
-        }
-        for (const file of artifact.files ?? []) {
-            if (!(file.target && file.content !== undefined)) {
-                continue;
-            }
-            const target = resolveRegistryTarget(file.target);
-            if (target.endsWith("/package.json") || target === "package.json") {
-                prospectiveManifests.set(target, file.content);
-            }
-        }
-    }
-    const issues = (await Promise.all(plan.packageRequirements.map(async (requirement) => {
-        const manifest = path.posix.join(requirement.cwd, "package.json");
-        const prospective = prospectiveManifests.get(manifest);
-        try {
-            if (prospective !== undefined) {
-                parsePackageJson(prospective, manifest);
-            }
-            else if (!removed.has(manifest) &&
-                (await pathExists(path.join(workspaceRoot, manifest)))) {
-                await readPackageJson(path.join(workspaceRoot, manifest), manifest);
-            }
-            else {
-                return `${manifest} is not present or supplied by the selected graph`;
-            }
-        }
-        catch (error) {
-            if (error instanceof CompositionValidationError) {
-                return `${manifest}: ${error.issues.join("; ")}`;
-            }
-            return `${manifest} could not be read`;
-        }
-    }))).filter((issue) => issue !== undefined);
-    if (issues.length > 0) {
-        throw new CompositionValidationError("Package requirements have invalid package.json targets.", [...new Set(issues)].sort((left, right) => left.localeCompare(right)));
-    }
-}
-export async function installPreparedComposition(workspaceRoot, prepared) {
-    await Promise.all(prepared.assets.map(async (asset) => {
-        const target = path.join(workspaceRoot, asset.target);
-        await mkdir(path.dirname(target), { recursive: true });
-        await writeFile(target, asset.content);
-    }));
-    await withPreparedRegistryArtifacts({
-        artifacts: prepared.artifacts.map((artifact) => ({
-            ...artifact,
-            docs: undefined,
-        })),
-        entryItems: prepared.entryItems,
-        itemByReference: prepared.itemByReference,
-        run: async (entries) => {
-            await addRegistryItemsQuietly(entries, {
-                config: prepared.registryConfig,
-                cwd: workspaceRoot,
-                overwrite: true,
-            });
-        },
-    });
-}

package/dist/composition/packages.d.ts

@@ -1,6 +0,0 @@
-import type { DependencySection, PackageRequirement, SelectionDefinition } from "./types.js";
-export type PackageJson = Partial<Record<DependencySection, Record<string, string>>> & Record<string, unknown>;
-export declare function parsePackageJson(source: string, label: string): PackageJson;
-export declare function readPackageJson(filePath: string, label?: string): Promise<PackageJson>;
-export declare function mergePackageRequirements(selections: Pick<SelectionDefinition, "packages">[]): PackageRequirement[];
-//# sourceMappingURL=packages.d.ts.map

package/dist/composition/packages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"packages.d.ts","sourceRoot":"","sources":["../../src/composition/packages.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAWpB,MAAM,MAAM,WAAW,GAAG,OAAO,CAC/B,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAClD,GACC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAe1B,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAY3E;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,KAAK,SAAW,GACf,OAAO,CAAC,WAAW,CAAC,CAEtB;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,GAClD,kBAAkB,EAAE,CA8BtB"}

package/dist/composition/packages.js

@@ -1,54 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { z } from "zod";
-import { CompositionValidationError } from "./errors.js";
-import { formatZodError } from "./schema.js";
-const dependencyEntriesSchema = z.record(z.string());
-const packageJsonSchema = z
-    .object({
-    dependencies: dependencyEntriesSchema.optional(),
-    devDependencies: dependencyEntriesSchema.optional(),
-    optionalDependencies: dependencyEntriesSchema.optional(),
-})
-    .passthrough();
-function decodePackageJson(value, label) {
-    const result = packageJsonSchema.safeParse(value);
-    if (!result.success) {
-        throw new CompositionValidationError(`${label} is not a valid package.json file.`, formatZodError(result.error));
-    }
-    // Zod reconstructs objects in schema order, so return the validated input
-    // to preserve the manifest's existing key positions.
-    return value;
-}
-export function parsePackageJson(source, label) {
-    let value;
-    try {
-        value = JSON.parse(source);
-    }
-    catch (error) {
-        throw new CompositionValidationError(`${label} is not a valid package.json file.`, [error instanceof Error ? error.message : "JSON parsing failed"], { cause: error });
-    }
-    return decodePackageJson(value, label);
-}
-export async function readPackageJson(filePath, label = filePath) {
-    return parsePackageJson(await readFile(filePath, "utf-8"), label);
-}
-export function mergePackageRequirements(selections) {
-    const requirements = new Map();
-    const issues = [];
-    for (const selection of selections) {
-        for (const requirement of selection.packages) {
-            const key = `${requirement.cwd}\0${requirement.section}\0${requirement.name}`;
-            const existing = requirements.get(key);
-            if (existing && existing.specifier !== requirement.specifier) {
-                issues.push(`${requirement.cwd}/${requirement.section}.${requirement.name} is requested as both ${existing.specifier} and ${requirement.specifier}`);
-            }
-            else {
-                requirements.set(key, requirement);
-            }
-        }
-    }
-    if (issues.length > 0) {
-        throw new CompositionValidationError("Package requirements conflict.", [...new Set(issues)].sort((left, right) => left.localeCompare(right)));
-    }
-    return [...requirements.values()].sort((left, right) => `${left.cwd}/${left.section}/${left.name}`.localeCompare(`${right.cwd}/${right.section}/${right.name}`));
-}