create-next-hydra 0.1.0 → 0.2.0

package/dist/composition/schema.js

@@ -0,0 +1,115 @@
+import path from "node:path";
+import { z } from "zod";
+import { PROVIDER_SLOTS } from "./types.js";
+export const NEXT_HYDRA_SELECTION_SCHEMA_URL = "https://raw.githubusercontent.com/jakala-na/next-hydra/main/packages/create-next-hydra/schema/selection-definition.json";
+const workspaceRelativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.startsWith("/"), "must be workspace-relative")
+    .refine((value) => !value.includes("\\"), "must use forward slashes")
+    .refine((value) => !value.split("/").includes(".."), "must not escape the workspace");
+const workspaceFilePathSchema = workspaceRelativePathSchema.refine((value) => ![".", "./"].includes(path.posix.normalize(value)), "must name a file or directory below the workspace root");
+const packageRequirementSchema = z
+    .object({
+    cwd: workspaceRelativePathSchema,
+    name: z.string().min(1),
+    section: z.enum([
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+    ]),
+    specifier: z.string().min(1),
+})
+    .strict();
+const pnpmPatchSchema = z
+    .object({
+    dependency: z.string().min(1),
+    path: workspaceFilePathSchema,
+})
+    .strict();
+const providerSelectionsSchema = z
+    .object({
+    auth: z.string().min(1).optional(),
+    cms: z.string().min(1).optional(),
+    commerce: z.string().min(1).optional(),
+})
+    .strict();
+const presetSelectionsSchema = z
+    .object({
+    addOns: z.array(z.string().min(1)).default([]),
+    providers: providerSelectionsSchema.optional(),
+})
+    .strict();
+export const selectionDefinitionSchema = z
+    .object({
+    assets: z
+        .array(z
+        .object({
+        source: workspaceFilePathSchema,
+        target: workspaceFilePathSchema,
+    })
+        .strict())
+        .default([]),
+    compatibility: z
+        .object({
+        conflicts: z.array(z.string().min(1)).default([]),
+        requires: z.array(z.string().min(1)).default([]),
+    })
+        .strict()
+        .default({ conflicts: [], requires: [] }),
+    id: z.string().min(1),
+    kind: z.enum(["provider", "add-on", "preset"]),
+    packages: z.array(packageRequirementSchema).default([]),
+    pnpmPatches: z.array(pnpmPatchSchema).default([]),
+    selections: presetSelectionsSchema.optional(),
+    slot: z.enum(PROVIDER_SLOTS).optional(),
+})
+    .strict()
+    .superRefine((definition, context) => {
+    if (definition.kind === "provider" && !definition.slot) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "a provider must declare its slot",
+            path: ["slot"],
+        });
+    }
+    if (definition.kind !== "provider" && definition.slot) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${definition.kind} must not declare a provider slot`,
+            path: ["slot"],
+        });
+    }
+    if (definition.kind === "preset" && !definition.selections) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "a preset must declare selections",
+            path: ["selections"],
+        });
+    }
+    if (definition.kind !== "preset" && definition.selections) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${definition.kind} must not declare preset selections`,
+            path: ["selections"],
+        });
+    }
+});
+export const workspaceSelectionSchema = z
+    .object({
+    addOns: z.array(z.string().min(1)).default([]),
+    providers: z
+        .object({
+        auth: z.string().min(1),
+        cms: z.string().min(1),
+        commerce: z.string().min(1),
+    })
+        .strict(),
+})
+    .strict();
+export function formatZodError(error) {
+    return error.issues.map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join(".") : "value";
+        return `${location}: ${issue.message}`;
+    });
+}

package/dist/composition/types.d.ts

@@ -0,0 +1,87 @@
+import type { getRegistriesConfig } from "shadcn/registry";
+import type { RegistryItem } from "shadcn/schema";
+export type RegistriesConfig = Awaited<ReturnType<typeof getRegistriesConfig>>;
+export declare const PROVIDER_SLOTS: readonly ["auth", "cms", "commerce"];
+export type ProviderSlot = (typeof PROVIDER_SLOTS)[number];
+export declare const PROVIDER_ALIASES: Record<ProviderSlot, string>;
+export type SelectionKind = "provider" | "add-on" | "preset";
+export type DependencySection = "dependencies" | "devDependencies" | "optionalDependencies";
+export type PackageRequirement = {
+    cwd: string;
+    section: DependencySection;
+    name: string;
+    specifier: string;
+};
+export type AssetContribution = {
+    source: string;
+    target: string;
+};
+export type PnpmPatch = {
+    dependency: string;
+    path: string;
+};
+export type WorkspaceSelection = {
+    providers: Record<ProviderSlot, string>;
+    addOns: string[];
+};
+export type SelectionDefinition = {
+    id: string;
+    kind: SelectionKind;
+    slot?: ProviderSlot;
+    compatibility: {
+        requires: string[];
+        conflicts: string[];
+    };
+    packages: PackageRequirement[];
+    pnpmPatches: PnpmPatch[];
+    assets: AssetContribution[];
+    selections?: {
+        providers?: Partial<Record<ProviderSlot, string>>;
+        addOns: string[];
+    };
+};
+export type CatalogSelection = SelectionDefinition & {
+    itemName: string;
+};
+export type SourceRegistryCatalog = {
+    cwd: string;
+    registryFile: string;
+    repository?: string;
+    authoringPaths: string[];
+    items: Map<string, RegistryItem>;
+    itemByReference: Map<string, string>;
+    registryConfig: RegistriesConfig;
+    selections: CatalogSelection[];
+    byId: Map<string, CatalogSelection>;
+    byReference: Map<string, CatalogSelection>;
+    managedTargets: string[];
+};
+export type PreparedComposition = {
+    artifacts: RegistryItem[];
+    itemByReference: Map<string, string>;
+    entryItems: string[];
+    registryConfig: RegistriesConfig;
+    assets: (AssetContribution & {
+        content: Uint8Array;
+    })[];
+    managedFiles: {
+        content: string;
+        target: string;
+    }[];
+};
+export type CompositionPlan = {
+    selection: WorkspaceSelection;
+    selections: CatalogSelection[];
+    entryItems: string[];
+    registryItems: string[];
+    packageRequirements: PackageRequirement[];
+    catalogPackageRequirements: PackageRequirement[];
+    pnpmPatches: PnpmPatch[];
+    catalogPnpmPatches: PnpmPatch[];
+    assets: AssetContribution[];
+    managedTargets: string[];
+    catalogManagedTargets: string[];
+    variableTargets: string[];
+    instructions: string[];
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/composition/types.ts"],"names":[],"mappings":"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"}

package/dist/composition/types.js

@@ -0,0 +1,6 @@
+export const PROVIDER_SLOTS = ["auth", "cms", "commerce"];
+export const PROVIDER_ALIASES = {
+    auth: "@repo/auth",
+    cms: "@repo/cms",
+    commerce: "@repo/commerce-provider",
+};

package/dist/composition/use.d.ts

@@ -0,0 +1,23 @@
+import { confirm } from "@clack/prompts";
+import { runCommand } from "../git.js";
+export type UseCompositionOptions = {
+    cwd?: string;
+    auth?: string;
+    cms?: string;
+    commerce?: string;
+    addOns?: string[];
+    preset?: string;
+    check?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+    verbose?: boolean;
+};
+type ConfirmPrompt = (options: Parameters<typeof confirm>[0]) => ReturnType<typeof confirm>;
+type UseDependencies = {
+    confirm?: ConfirmPrompt;
+    install?: (cwd: string, verbose: boolean) => Promise<void>;
+};
+export declare function installCompositionDependencies(cwd: string, verbose: boolean, execute?: typeof runCommand): Promise<void>;
+export declare function useComposition(options: UseCompositionOptions, dependencies?: UseDependencies): Promise<void>;
+export {};
+//# sourceMappingURL=use.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use.d.ts","sourceRoot":"","sources":["../../src/composition/use.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAY,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAyB,UAAU,EAAE,MAAM,WAAW,CAAC;AA0B9D,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,aAAa,GAAG,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,KACnC,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAEhC,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D,CAAC;AA+DF,wBAAsB,8BAA8B,CAClD,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,OAAO,UAAuB,GACtC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,EAC9B,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,IAAI,CAAC,CAyJf"}

package/dist/composition/use.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { CommandExecutionError, runCommand } from "../git.js";
+import { info, printInstructions, success } from "../logger.js";
+import { addCatalogReferences, loadSourceRegistryCatalog } from "./catalog.js";
+import { CompositionValidationError } from "./errors.js";
+import { formatCompositionPlan, formatCompositionPreview, formatCompositionResult, hasCompositionChanges, } from "./format.js";
+import { installPreparedComposition, prepareComposition, validatePackageRequirementTargets, } from "./install.js";
+import { planComposition, selectionFromPreset } from "./planner.js";
+import { applyPackageRequirements, applyPnpmPatches, checkWorkspaceComposition, readWorkspaceSelection, removeWorkspaceTargets, writeWorkspaceSelection, } from "./workspace.js";
+function requestedSelection(current, options, presetSelection) {
+    const providers = presetSelection
+        ? { ...presetSelection.providers }
+        : { ...current.providers };
+    const providerOverrides = {
+        auth: options.auth,
+        cms: options.cms,
+        commerce: options.commerce,
+    };
+    for (const [slot, reference] of Object.entries(providerOverrides)) {
+        if (reference) {
+            providers[slot] = reference;
+        }
+    }
+    const presetAddOns = presetSelection ? presetSelection.addOns : [];
+    let addOns = presetSelection ? presetAddOns : current.addOns;
+    if (options.addOns) {
+        addOns = [...presetAddOns, ...options.addOns];
+    }
+    return {
+        ...current,
+        addOns: [...new Set(addOns)],
+        providers,
+    };
+}
+function operationFailure(error, failed, completed, pending) {
+    let cause = error instanceof Error ? error.message : String(error);
+    if (error instanceof CommandExecutionError) {
+        const output = error.stderr.trim() || error.stdout.trim();
+        if (output) {
+            cause = `${cause}\n${output}`;
+        }
+    }
+    return new Error([
+        `Composition stopped while ${failed}.`,
+        `Completed: ${completed.length > 0 ? completed.join(", ") : "none"}.`,
+        `Not attempted: ${pending.length > 0 ? pending.join(", ") : "none"}.`,
+        "The workspace changes have been left in place for inspection or repair.",
+        "",
+        cause,
+    ].join("\n"));
+}
+export async function installCompositionDependencies(cwd, verbose, execute = runCommand) {
+    await execute("pnpm", ["install", "--no-frozen-lockfile"], {
+        cwd,
+        verbose,
+    });
+}
+export async function useComposition(options, dependencies = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const current = await readWorkspaceSelection(cwd);
+    if (options.check &&
+        (options.auth ||
+            options.cms ||
+            options.commerce ||
+            options.preset ||
+            options.addOns)) {
+        throw new Error("`use --check` reads next-hydra.json and accepts no selections.");
+    }
+    if (options.check && options.dryRun) {
+        throw new Error("`use --check` cannot be combined with `--dry-run`.");
+    }
+    if (options.preset && (options.auth || options.cms || options.commerce)) {
+        throw new Error("`use --preset` cannot be combined with provider flags.");
+    }
+    let catalog = await loadSourceRegistryCatalog(cwd);
+    catalog = await addCatalogReferences(catalog, [
+        ...Object.values(current.providers),
+        ...current.addOns,
+        ...[options.auth, options.cms, options.commerce, options.preset].filter((value) => Boolean(value)),
+        ...(options.addOns ?? []),
+    ]);
+    const presetSelection = options.preset
+        ? selectionFromPreset(catalog, options.preset)
+        : undefined;
+    const selection = options.check
+        ? current
+        : requestedSelection(current, options, presetSelection);
+    catalog = await addCatalogReferences(catalog, [
+        ...Object.values(selection.providers),
+        ...selection.addOns,
+    ]);
+    const plan = planComposition(catalog, selection);
+    const prepared = await prepareComposition(catalog, plan);
+    await validatePackageRequirementTargets(cwd, plan, prepared, plan.catalogManagedTargets);
+    if (options.check) {
+        info("Checking the maintainer workspace against next-hydra.json.");
+        if (options.verbose) {
+            info(`Composition plan:\n${formatCompositionPlan(plan)}`);
+        }
+        const drift = await checkWorkspaceComposition(cwd, plan, prepared.managedFiles);
+        if (drift.length > 0) {
+            throw new CompositionValidationError("The maintainer workspace differs from next-hydra.json.", drift);
+        }
+        success("The maintainer workspace matches next-hydra.json.");
+        return;
+    }
+    info(formatCompositionPreview(current, plan.selection));
+    if (options.verbose) {
+        info(`Composition plan:\n${formatCompositionPlan(plan)}`);
+    }
+    if (!hasCompositionChanges(current, plan.selection)) {
+        success(formatCompositionResult(current, plan.selection));
+        return;
+    }
+    if (options.dryRun) {
+        success("Dry run complete. No changes were made.");
+        return;
+    }
+    if (!options.yes) {
+        const approved = await (dependencies.confirm ?? confirm)({
+            initialValue: false,
+            message: "Apply these composition changes?",
+        });
+        if (isCancel(approved) || !approved) {
+            throw new Error("Composition cancelled. No changes were made.");
+        }
+    }
+    const completed = [];
+    const pending = [
+        "write next-hydra.json",
+        "remove managed application files",
+        "install selected source",
+        "update package aliases",
+        "update pnpm patches",
+        "install dependencies",
+    ];
+    const runStep = async (label, operation) => {
+        pending.shift();
+        try {
+            await operation();
+            completed.push(label);
+        }
+        catch (error) {
+            throw operationFailure(error, label, completed, pending);
+        }
+    };
+    await runStep("write next-hydra.json", async () => {
+        await writeWorkspaceSelection(cwd, plan.selection);
+    });
+    await runStep("remove managed application files", async () => {
+        await removeWorkspaceTargets(cwd, plan.catalogManagedTargets);
+    });
+    await runStep("install selected source", async () => {
+        await installPreparedComposition(cwd, prepared);
+    });
+    await runStep("update package aliases", async () => {
+        await applyPackageRequirements(cwd, plan);
+    });
+    await runStep("update pnpm patches", async () => {
+        await applyPnpmPatches(cwd, plan);
+    });
+    await runStep("install dependencies", async () => {
+        if (dependencies.install) {
+            await dependencies.install(cwd, options.verbose ?? false);
+            return;
+        }
+        await installCompositionDependencies(cwd, options.verbose ?? false);
+    });
+    if (plan.instructions.length > 0) {
+        printInstructions([
+            {
+                entries: plan.instructions.map((text) => ({
+                    kind: "text",
+                    text,
+                })),
+                title: "Provider setup",
+            },
+        ]);
+    }
+    success(formatCompositionResult(current, plan.selection));
+}

package/dist/composition/workspace.d.ts

@@ -0,0 +1,10 @@
+import type { CompositionPlan, PreparedComposition, WorkspaceSelection } from "./types.js";
+export declare const WORKSPACE_SELECTION_FILE = "next-hydra.json";
+export declare function readWorkspaceSelection(workspaceRoot: string): Promise<WorkspaceSelection>;
+export declare function writeWorkspaceSelection(workspaceRoot: string, selection: WorkspaceSelection): Promise<void>;
+export declare function applyPackageRequirements(workspaceRoot: string, plan: CompositionPlan): Promise<void>;
+export declare function applyPackageEntries(workspaceRoot: string, requirements: CompositionPlan["packageRequirements"]): Promise<void>;
+export declare function applyPnpmPatches(workspaceRoot: string, plan: CompositionPlan): Promise<void>;
+export declare function removeWorkspaceTargets(workspaceRoot: string, targets: string[]): Promise<void>;
+export declare function checkWorkspaceComposition(workspaceRoot: string, plan: CompositionPlan, managedFiles: PreparedComposition["managedFiles"]): Promise<string[]>;
+//# sourceMappingURL=workspace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/composition/workspace.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,oBAAoB,CAAC;AAE1D,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAyB7B;AAED,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,kBAAkB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,wBAAwB,CAC5C,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CA6Cf;AAED,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,eAAe,CAAC,qBAAqB,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,CAgCf;AAuBD,wBAAsB,gBAAgB,CACpC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAyBD,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAsB,yBAAyB,CAC7C,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAkGnB"}

package/dist/composition/workspace.js

@@ -0,0 +1,208 @@
+import { readdir, readFile, rmdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDocument } from "yaml";
+import { pathExists, readJsonFile, removePath, writeJsonFile, } from "../fs-utils.js";
+import { CompositionValidationError } from "./errors.js";
+import { readPackageJson } from "./packages.js";
+import { formatZodError, workspaceSelectionSchema } from "./schema.js";
+export const WORKSPACE_SELECTION_FILE = "next-hydra.json";
+export async function readWorkspaceSelection(workspaceRoot) {
+    const filePath = path.join(workspaceRoot, WORKSPACE_SELECTION_FILE);
+    if (!(await pathExists(filePath))) {
+        throw new Error(`${WORKSPACE_SELECTION_FILE} was not found. The \`use\` command only operates on a Next Hydra maintainer workspace.`);
+    }
+    const value = await readJsonFile(filePath);
+    const result = workspaceSelectionSchema.safeParse(value);
+    if (!result.success) {
+        throw new CompositionValidationError(`${WORKSPACE_SELECTION_FILE} is invalid.`, formatZodError(result.error));
+    }
+    // Preserve existing top-level and nested key positions, appending only
+    // schema-defaulted keys that were absent from the file.
+    const selection = value;
+    for (const [key, defaultedValue] of Object.entries(result.data)) {
+        if (!Object.hasOwn(selection, key)) {
+            selection[key] = defaultedValue;
+        }
+    }
+    return value;
+}
+export async function writeWorkspaceSelection(workspaceRoot, selection) {
+    await writeJsonFile(path.join(workspaceRoot, WORKSPACE_SELECTION_FILE), selection);
+}
+export async function applyPackageRequirements(workspaceRoot, plan) {
+    const selected = new Set(plan.packageRequirements.map((requirement) => `${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
+    const removals = plan.catalogPackageRequirements.filter((requirement) => !selected.has(`${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
+    const byManifest = new Map();
+    for (const requirement of removals) {
+        const manifest = path.posix.join(requirement.cwd, "package.json");
+        const entries = byManifest.get(manifest) ?? [];
+        entries.push(requirement);
+        byManifest.set(manifest, entries);
+    }
+    await Promise.all([...byManifest].map(async ([manifest, entries]) => {
+        const manifestPath = path.join(workspaceRoot, manifest);
+        if (!(await pathExists(manifestPath))) {
+            return;
+        }
+        const packageJson = await readPackageJson(manifestPath, manifest);
+        let changed = false;
+        for (const requirement of entries) {
+            const section = packageJson[requirement.section];
+            if (!(section && Object.hasOwn(section, requirement.name))) {
+                continue;
+            }
+            delete section[requirement.name];
+            changed = true;
+        }
+        if (changed) {
+            await writeJsonFile(manifestPath, packageJson);
+        }
+    }));
+    await applyPackageEntries(workspaceRoot, plan.packageRequirements);
+}
+export async function applyPackageEntries(workspaceRoot, requirements) {
+    const byManifest = new Map();
+    for (const requirement of requirements) {
+        const manifest = path.posix.join(requirement.cwd, "package.json");
+        const existing = byManifest.get(manifest) ?? [];
+        existing.push(requirement);
+        byManifest.set(manifest, existing);
+    }
+    await Promise.all([...byManifest].map(async ([manifest, manifestRequirements]) => {
+        const manifestPath = path.join(workspaceRoot, manifest);
+        const packageJson = await readPackageJson(manifestPath, manifest);
+        let changed = false;
+        for (const requirement of manifestRequirements) {
+            const section = packageJson[requirement.section] ?? {};
+            if (Object.hasOwn(section, requirement.name) &&
+                section[requirement.name] === requirement.specifier) {
+                continue;
+            }
+            section[requirement.name] = requirement.specifier;
+            packageJson[requirement.section] = section;
+            changed = true;
+        }
+        if (changed) {
+            await writeJsonFile(manifestPath, packageJson);
+        }
+    }));
+}
+function readPnpmWorkspaceConfig(source) {
+    const document = parseDocument(source);
+    if (document.errors.length > 0) {
+        throw new CompositionValidationError("pnpm-workspace.yaml is invalid.", document.errors.map((error) => error.message));
+    }
+    return {
+        config: document.toJS(),
+        document,
+    };
+}
+export async function applyPnpmPatches(workspaceRoot, plan) {
+    if (plan.catalogPnpmPatches.length === 0) {
+        return;
+    }
+    const workspaceFile = path.join(workspaceRoot, "pnpm-workspace.yaml");
+    const { config, document } = readPnpmWorkspaceConfig(await readFile(workspaceFile, "utf-8"));
+    const governedDependencies = new Set(plan.catalogPnpmPatches.map((patch) => patch.dependency));
+    const patches = Object.fromEntries(Object.entries(config.patchedDependencies ?? {}).filter(([dependency]) => !governedDependencies.has(dependency)));
+    for (const patch of plan.pnpmPatches) {
+        patches[patch.dependency] = patch.path;
+    }
+    const sortedPatches = Object.fromEntries(Object.entries(patches).sort(([left], [right]) => left.localeCompare(right)));
+    if (Object.keys(sortedPatches).length === 0) {
+        document.delete("patchedDependencies");
+    }
+    else {
+        document.set("patchedDependencies", sortedPatches);
+    }
+    await writeFile(workspaceFile, document.toString(), "utf-8");
+}
+async function pruneEmptyParents(workspaceRoot, relativeTarget) {
+    let current = path.dirname(path.join(workspaceRoot, relativeTarget));
+    const root = path.resolve(workspaceRoot);
+    while (current.startsWith(`${root}${path.sep}`)) {
+        try {
+            // Parent directories must be checked from the leaf toward the root.
+            // oxlint-disable-next-line no-await-in-loop -- Each iteration depends on the previous parent.
+            const entries = await readdir(current);
+            if (entries.length > 0) {
+                return;
+            }
+            await rmdir(current);
+            current = path.dirname(current);
+        }
+        catch {
+            return;
+        }
+    }
+}
+export async function removeWorkspaceTargets(workspaceRoot, targets) {
+    const deepestFirst = [...targets].sort((left, right) => right.split("/").length - left.split("/").length);
+    for (const target of deepestFirst) {
+        // Targets are deepest-first so pruning one target cannot race another.
+        // oxlint-disable-next-line no-await-in-loop -- Ordered removal keeps parent pruning deterministic.
+        await removePath(path.join(workspaceRoot, target));
+        await pruneEmptyParents(workspaceRoot, target);
+    }
+}
+export async function checkWorkspaceComposition(workspaceRoot, plan, managedFiles) {
+    const drift = [];
+    const selected = new Set(plan.packageRequirements.map((requirement) => `${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
+    const unselectedPackageDrift = await Promise.all(plan.catalogPackageRequirements.map(async (requirement) => {
+        const key = `${requirement.cwd}\0${requirement.section}\0${requirement.name}`;
+        if (selected.has(key)) {
+            return;
+        }
+        const manifest = path.posix.join(requirement.cwd, "package.json");
+        const manifestPath = path.join(workspaceRoot, manifest);
+        if (!(await pathExists(manifestPath))) {
+            return;
+        }
+        const packageJson = await readPackageJson(manifestPath, manifest);
+        const actual = packageJson[requirement.section]?.[requirement.name];
+        return actual === undefined
+            ? undefined
+            : `${manifest}: expected unselected ${requirement.section}.${requirement.name} to be absent, found ${actual}`;
+    }));
+    drift.push(...unselectedPackageDrift.filter((issue) => issue !== undefined));
+    const selectedPackageDrift = await Promise.all(plan.packageRequirements.map(async (requirement) => {
+        const manifest = path.posix.join(requirement.cwd, "package.json");
+        const packageJson = await readPackageJson(path.join(workspaceRoot, manifest), manifest);
+        const actual = packageJson[requirement.section]?.[requirement.name];
+        return actual === requirement.specifier
+            ? undefined
+            : `${manifest}: expected ${requirement.section}.${requirement.name} to be ${requirement.specifier}, found ${actual ?? "missing"}`;
+    }));
+    drift.push(...selectedPackageDrift.filter((issue) => issue !== undefined));
+    if (plan.catalogPnpmPatches.length > 0) {
+        const workspaceFile = path.join(workspaceRoot, "pnpm-workspace.yaml");
+        const { config } = readPnpmWorkspaceConfig(await readFile(workspaceFile, "utf-8"));
+        const selectedPatches = new Map(plan.pnpmPatches.map((patch) => [patch.dependency, patch.path]));
+        for (const patch of plan.catalogPnpmPatches) {
+            const expected = selectedPatches.get(patch.dependency);
+            const actual = config.patchedDependencies?.[patch.dependency];
+            if (actual !== expected) {
+                drift.push(`pnpm-workspace.yaml: expected patchedDependencies.${patch.dependency} to be ${expected ?? "absent"}, found ${actual ?? "missing"}`);
+            }
+        }
+    }
+    const expectedManagedFiles = new Map(managedFiles.map((file) => [file.target, file.content]));
+    const managedFileDrift = await Promise.all(plan.catalogManagedTargets.map(async (target) => {
+        const filePath = path.join(workspaceRoot, target);
+        const expected = expectedManagedFiles.get(target);
+        if (!expected) {
+            return (await pathExists(filePath))
+                ? `${target}: managed file should not exist for this composition`
+                : undefined;
+        }
+        if (!(await pathExists(filePath))) {
+            return `${target}: managed file is missing`;
+        }
+        const actual = await readFile(filePath, "utf-8");
+        return actual === expected
+            ? undefined
+            : `${target}: managed file differs from the composition plan`;
+    }));
+    drift.push(...managedFileDrift.filter((issue) => issue !== undefined));
+    return drift.sort((left, right) => left.localeCompare(right));
+}

package/dist/constants.d.ts

@@ -4,5 +4,8 @@ export declare const DEFAULT_REPO_URL = "https://github.com/jakala-na/next-hydra
 export declare const DEFAULT_COMMIT_MESSAGE = "Initial commit";
 export declare const DEFAULT_PACKAGE_MANAGER = "pnpm";
 export declare const DEFAULT_STARTER: StarterDefinition;
-export declare const SANITIZE_REMOVE_PATHS: readonly [".git", "apps/docs", "pnpm-lock.yaml"];
+export declare const SANITIZE_REMOVE_PATHS: readonly [".changeset", ".git", ".github/workflows/registry-integrity.yml", ".github/workflows/release-create-next-hydra.yml", ".scratch", "RELEASING.md", "apps/docs", "next-hydra.json", "packages/create-next-hydra", "scripts/release-create-next-hydra.mjs", "scripts/sync-registry-files.ts"];
+export declare const SANITIZE_REMOVE_SCRIPTS: readonly ["changeset", "changeset:status", "publish:cli", "registry:check", "registry:sync", "release:create-next-hydra", "release:create-next-hydra:dry-run", "version:cli"];
+export declare const SANITIZE_REMOVE_ROOT_DEPENDENCIES: readonly ["@clack/prompts", "commander"];
+export declare const SANITIZE_REMOVE_ROOT_DEV_DEPENDENCIES: readonly ["@changesets/cli"];
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,QAAQ,sBAAsB,CAAC;AAC5C,eAAO,MAAM,gBAAgB,gDAAgD,CAAC;AAC9E,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,iBAG7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,kDAIxB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,QAAQ,sBAAsB,CAAC;AAC5C,eAAO,MAAM,gBAAgB,gDAAgD,CAAC;AAC9E,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,iBAG7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,YAChC,YAAY,EACZ,MAAM,EACN,0CAA0C,EAC1C,iDAAiD,EACjD,UAAU,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,4BAA4B,EAC5B,uCAAuC,EACvC,gCAAgC,CACxB,CAAC;AAEX,eAAO,MAAM,uBAAuB,YAClC,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,2BAA2B,EAC3B,mCAAmC,EACnC,aAAa,CACL,CAAC;AAEX,eAAO,MAAM,iCAAiC,YAC5C,gBAAgB,EAChB,WAAW,CACH,CAAC;AAEX,eAAO,MAAM,qCAAqC,YAChD,iBAAiB,CACT,CAAC"}