@ykdz/template 0.0.2 → 0.0.4

package/README.md

@@ -12,7 +12,7 @@ Available commands:
 
 ```sh
 template init <dir> --preset <name> --yes
-template add package --preset <name> --name <name>
+template add package --preset <name> --name <name> [--path <package-path>]
 template presets
 template schema preset
 template schema blueprint

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/{cli.js → src/cli.js}

@@ -2,21 +2,17 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { initHonoApiProject } from "./hono-api.js";
-import { initRustBinProject } from "./rust-bin.js";
-import { initTsLibProject } from "./ts-lib.js";
-import { initVueHonoAppProject } from "./vue-hono-app.js";
-import { initVueAppProject } from "./vue-app.js";
-import { addPackage } from "./package-addition.js";
-import { assembleGenerationContext } from "./generation-context.js";
-import { planNextStepInstructions, } from "./next-step-instructions.js";
+import { findBuiltInPresetProjection, projectPresetThroughRegistry, } from "../templates/registry.js";
 import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
+import { assembleGenerationContext, } from "./generation-context.js";
+import { addPackage } from "./package-addition.js";
+import { planNextStepInstructionsForProjection, } from "./preset-projection.js";
 import { resolveToolchainVersions, } from "./toolchain-resolution.js";
 function usage() {
     return [
         "Usage:",
         "  template init <dir> --preset <name> --yes",
-        "  template add package --preset <name> --name <name>",
+        "  template add package --preset <name> --name <name> [--path <package-path>]",
         "  template presets",
         "  template schema preset",
         "  template schema blueprint",
@@ -26,6 +22,7 @@ function usage() {
         "Options:",
         "  --preset <name>  Project preset to generate",
         "  --name <name>    Package name to add",
+        "  --path <path>    Two-segment Package Path to add",
         "  --scope <name>   Package scope for workspace package names",
         "  --yes            Accept defaults for non-interactive generation",
         "  --dry-run        Print the planned generation without writing files",
@@ -50,7 +47,9 @@ async function readJsonDeclaration(filePath) {
     }
 }
 function formatValidationIssues(issues) {
-    return issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n");
+    return issues
+        .map((issue) => `  - ${issue.path}: ${issue.message}`)
+        .join("\n");
 }
 function formatPresetCatalog() {
     return [
@@ -117,20 +116,31 @@ function normalizeNpmScope(value) {
 function supportedPreset(name) {
     const preset = builtInPresets.find((candidate) => candidate.name === name && candidate.generation === "supported");
     if (!preset) {
-        throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+        throw new Error(formatSupportedPresetError());
     }
     return preset;
 }
-function projectNameFromDir(targetDir) {
-    return path.basename(path.resolve(targetDir));
+function formatSupportedPresetError() {
+    const supportedPresetNames = builtInPresets
+        .filter((preset) => preset.generation === "supported")
+        .map((preset) => preset.name);
+    return `Only the ${formatList(supportedPresetNames)} presets are supported in this version`;
 }
-function scopeFromOptions(projectName, scope) {
-    return scope ?? projectName;
+function formatList(values) {
+    if (values.length <= 1) {
+        return values[0] ?? "";
+    }
+    return `${values.slice(0, -1).join(", ")}, and ${values.at(-1)}`;
 }
 function blueprintForInit(options) {
     const preset = supportedPreset(options.preset);
-    const projectName = projectNameFromDir(options.dir);
-    const packageScope = scopeFromOptions(projectName, options.scope);
+    const projection = findBuiltInPresetProjection(preset.name);
+    if (projection) {
+        return projection.blueprint({
+            targetDir: options.dir,
+            scope: options.scope,
+        });
+    }
     const blueprint = {
         schemaVersion: 1,
         preset: preset.name,
@@ -140,12 +150,6 @@ function blueprintForInit(options) {
     if (preset.supportedPackageManagers[0]) {
         blueprint.packageManager = preset.supportedPackageManagers[0];
     }
-    if (preset.name === "vue-hono-app") {
-        blueprint.packages = [
-            { name: `@${packageScope}/web`, path: "apps/web" },
-            { name: `@${packageScope}/api`, path: "apps/api" },
-        ];
-    }
     return blueprint;
 }
 function formatBlueprintSummary(targetDir, blueprint) {
@@ -167,11 +171,14 @@ function formatBlueprintSummary(targetDir, blueprint) {
     lines.push(`  Features: ${blueprint.features.join(", ")}`);
     return lines.join("\n");
 }
-function formatNextSteps(targetDir, preset) {
-    const plan = planNextStepInstructions({ preset, targetDir });
+function formatProjectionNextSteps(targetDir, projectionPlan) {
+    const steps = planNextStepInstructionsForProjection({
+        targetDir,
+        plan: projectionPlan,
+    });
     return [
         "Next Step Instructions:",
-        ...plan.steps.map((step) => `  ${step.label}: ${step.display}`),
+        ...steps.map((step) => `  ${step.label}: ${step.display}`),
     ].join("\n");
 }
 function toolchainReport(toolchain) {
@@ -199,7 +206,7 @@ function toolchainResolutionSourceFromEnv() {
     return undefined;
 }
 async function generationContextForInit(options, blueprint) {
-    if (options.preset !== "ts-lib" && options.preset !== "rust-bin") {
+    if (!findBuiltInPresetProjection(options.preset)) {
         return undefined;
     }
     return assembleGenerationContext({
@@ -213,38 +220,37 @@ async function generationContextForInit(options, blueprint) {
     });
 }
 async function generateInitProject(options, generationContext) {
-    if (options.preset === "ts-lib") {
-        await initTsLibProject(options.dir, { generationContext });
-        return;
-    }
-    if (options.preset === "hono-api") {
-        await initHonoApiProject(options.dir);
-        return;
-    }
-    if (options.preset === "vue-app") {
-        await initVueAppProject(options.dir);
-        return;
-    }
-    if (options.preset === "vue-hono-app") {
-        await initVueHonoAppProject(options.dir, { scope: options.scope });
-        return;
-    }
-    if (options.preset === "rust-bin") {
-        await initRustBinProject(options.dir, { generationContext });
+    const projection = findBuiltInPresetProjection(options.preset);
+    if (projection) {
+        if (!generationContext) {
+            throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
+        }
+        const plan = projection.project(generationContext);
+        await projection.render({ targetDir: options.dir, plan });
         return;
     }
-    throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+    throw new Error(formatSupportedPresetError());
 }
 function printInitComplete(options, blueprint, generationContext) {
-    const preset = blueprint.preset;
-    const nextSteps = planNextStepInstructions({ preset, targetDir: options.dir }).steps;
+    const projectionPlan = generationContext
+        ? projectPresetThroughRegistry(generationContext)
+        : undefined;
+    if (!projectionPlan) {
+        throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
+    }
+    const nextSteps = planNextStepInstructionsForProjection({
+        targetDir: options.dir,
+        plan: projectionPlan,
+    });
     if (options.json) {
         printJson({
             command: "init",
             dryRun: false,
             targetDir: options.dir,
             blueprint,
-            toolchain: generationContext ? toolchainReport(generationContext.toolchain) : undefined,
+            toolchain: generationContext
+                ? toolchainReport(generationContext.toolchain)
+                : undefined,
             nextSteps,
         });
         return;
@@ -253,7 +259,7 @@ function printInitComplete(options, blueprint, generationContext) {
     if (generationContext) {
         console.log(formatToolchainReport(generationContext.toolchain));
     }
-    console.log(formatNextSteps(options.dir, preset));
+    console.log(formatProjectionNextSteps(options.dir, projectionPlan));
 }
 function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -266,7 +272,8 @@ async function confirmInit(targetDir, blueprint) {
     });
     try {
         const answer = await readline.question("Generate this project? [y/N] ");
-        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+        return (answer.trim().toLowerCase() === "y" ||
+            answer.trim().toLowerCase() === "yes");
     }
     finally {
         readline.close();
@@ -275,6 +282,7 @@ async function confirmInit(targetDir, blueprint) {
 function parseAddPackageOptions(args) {
     let preset = "";
     let name = "";
+    let packagePath;
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--preset") {
@@ -295,6 +303,15 @@ function parseAddPackageOptions(args) {
             index += 1;
             continue;
         }
+        if (arg === "--path") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--path requires a value");
+            }
+            packagePath = value;
+            index += 1;
+            continue;
+        }
         throw new Error(`Unknown option: ${arg}`);
     }
     if (!preset) {
@@ -303,7 +320,7 @@ function parseAddPackageOptions(args) {
     if (!name) {
         throw new Error("add package requires --name");
     }
-    return { preset, name };
+    return { preset, name, path: packagePath };
 }
 async function main(args) {
     const command = args[0];
@@ -352,23 +369,34 @@ async function main(args) {
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
             const generationContext = await generationContextForInit(options, blueprint);
-            const nextSteps = planNextStepInstructions({
-                preset: blueprint.preset,
+            const projectionPlan = generationContext
+                ? projectPresetThroughRegistry(generationContext)
+                : undefined;
+            if (!projectionPlan) {
+                throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
+            }
+            const nextSteps = planNextStepInstructionsForProjection({
                 targetDir: options.dir,
-            }).steps;
+                plan: projectionPlan,
+            });
             if (options.json) {
                 printJson({
                     command: "init",
                     dryRun: true,
                     targetDir: options.dir,
                     blueprint,
-                    toolchain: generationContext ? toolchainReport(generationContext.toolchain) : undefined,
+                    toolchain: generationContext
+                        ? toolchainReport(generationContext.toolchain)
+                        : undefined,
                     nextSteps,
                 });
                 return;
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
-            console.log(formatNextSteps(options.dir, blueprint.preset));
+            if (generationContext) {
+                console.log(formatToolchainReport(generationContext.toolchain));
+            }
+            console.log(formatProjectionNextSteps(options.dir, projectionPlan));
             return;
         }
         if (!options.yes && (options.json || !isInteractiveTerminal())) {
@@ -384,7 +412,12 @@ async function main(args) {
     }
     if (command === "add" && args[1] === "package") {
         const options = parseAddPackageOptions(args);
-        await addPackage({ cwd: process.cwd(), preset: options.preset, name: options.name });
+        await addPackage({
+            cwd: process.cwd(),
+            preset: options.preset,
+            name: options.name,
+            path: options.path,
+        });
         console.log(`Added ${options.preset} package ${options.name}`);
         return;
     }

package/dist/{declarations.d.ts → src/declarations.d.ts}

@@ -1,7 +1,6 @@
 import * as v from "valibot";
-export type PresetName = "ts-lib" | "hono-api" | "vue-app" | "vue-hono-app" | "rust-bin" | "ts-app" | "node-cli";
 export type BuiltInPreset = {
-    name: PresetName;
+    name: string;
     title: string;
     description: string;
     generation: "supported" | "future";
@@ -68,7 +67,7 @@ export declare const presetFileJsonSchema: {
             readonly type: "array";
             readonly minItems: 1;
             readonly items: {
-                readonly enum: readonly ["single-package", "multi-package"];
+                readonly enum: readonly ["multi-package"];
             };
             readonly uniqueItems: true;
         };
@@ -100,7 +99,7 @@ export declare const blueprintJsonSchema: {
             readonly enum: readonly ["pnpm"];
         };
         readonly projectKind: {
-            readonly enum: readonly ["single-package", "multi-package"];
+            readonly enum: readonly ["multi-package"];
         };
         readonly features: {
             readonly type: "array";
@@ -163,4 +162,3 @@ export type ValidationResult<T> = {
 export declare function validatePresetFile(input: unknown): ValidationResult<PresetFile>;
 export declare function findBuiltInPreset(name: string): BuiltInPreset | undefined;
 export declare function validateProjectBlueprint(input: unknown): ValidationResult<ProjectBlueprint>;
-//# sourceMappingURL=declarations.d.ts.map

package/dist/{declarations.js → src/declarations.js}

@@ -1,113 +1,6 @@
 import * as v from "valibot";
-export const builtInPresets = [
-    {
-        name: "ts-lib",
-        title: "TypeScript library",
-        description: "Strict TypeScript package with pnpm catalog tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "hono-api",
-        title: "Hono API",
-        description: "Single-package Hono Node API with strict TypeScript tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "vue-app",
-        title: "Vue app",
-        description: "Single-package Vue app with Vite, Tailwind, Pinia, and test tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "vue-hono-app",
-        title: "Vue Hono app",
-        description: "Full-stack Vue and Hono workspace with Hono RPC typing.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["multi-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "rust-bin",
-        title: "Rust binary",
-        description: "Single-package Rust native binary with rustfmt, clippy, and cargo tests.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot",
-            "rustfmt-clippy",
-            "cargo-test"
-        ]
-    },
-    {
-        name: "ts-app",
-        title: "TypeScript application",
-        description: "Future application preset metadata.",
-        generation: "future",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: []
-    },
-    {
-        name: "node-cli",
-        title: "Node.js CLI",
-        description: "Future command-line preset metadata.",
-        generation: "future",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: []
-    }
-];
+import { builtInPresetMetadata } from "../templates/registry.js";
+export const builtInPresets = builtInPresetMetadata;
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",
@@ -119,7 +12,7 @@ const featureNames = [
     "dependabot",
     "rustfmt-clippy",
     "cargo-test",
-    "native-binary-release"
+    "native-binary-release",
 ];
 export const presetFileJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -134,7 +27,7 @@ export const presetFileJsonSchema = {
         "description",
         "supportedPackageManagers",
         "supportedProjectKinds",
-        "features"
+        "features",
     ],
     properties: {
         schemaVersion: { const: 1 },
@@ -144,20 +37,20 @@ export const presetFileJsonSchema = {
         supportedPackageManagers: {
             type: "array",
             items: { enum: ["pnpm"] },
-            uniqueItems: true
+            uniqueItems: true,
         },
         supportedProjectKinds: {
             type: "array",
             minItems: 1,
-            items: { enum: ["single-package", "multi-package"] },
-            uniqueItems: true
+            items: { enum: ["multi-package"] },
+            uniqueItems: true,
         },
         features: {
             type: "array",
             items: { enum: featureNames },
-            uniqueItems: true
-        }
-    }
+            uniqueItems: true,
+        },
+    },
 };
 export const blueprintJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -170,11 +63,11 @@ export const blueprintJsonSchema = {
         schemaVersion: { const: 1 },
         preset: { type: "string", minLength: 1 },
         packageManager: { enum: ["pnpm"] },
-        projectKind: { enum: ["single-package", "multi-package"] },
+        projectKind: { enum: ["multi-package"] },
         features: {
             type: "array",
             items: { enum: featureNames },
-            uniqueItems: true
+            uniqueItems: true,
         },
         packages: {
             type: "array",
@@ -184,15 +77,18 @@ export const blueprintJsonSchema = {
                 required: ["name", "path"],
                 properties: {
                     name: { type: "string", minLength: 1 },
-                    path: { type: "string", minLength: 1 }
-                }
-            }
-        }
-    }
+                    path: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    },
 };
 const nonEmptyString = v.pipe(v.string(), v.minLength(1));
 const packageManagerSchema = v.picklist(["pnpm"]);
-const projectKindSchema = v.picklist(["single-package", "multi-package"]);
+const projectKindSchema = v.picklist([
+    "single-package",
+    "multi-package",
+]);
 const featureNameSchema = v.picklist(featureNames);
 export const presetFileSchema = v.strictObject({
     schemaVersion: v.literal(1),
@@ -201,7 +97,7 @@ export const presetFileSchema = v.strictObject({
     description: nonEmptyString,
     supportedPackageManagers: v.array(packageManagerSchema),
     supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
-    features: v.array(featureNameSchema)
+    features: v.array(featureNameSchema),
 });
 export const projectBlueprintSchema = v.strictObject({
     schemaVersion: v.literal(1),
@@ -211,8 +107,8 @@ export const projectBlueprintSchema = v.strictObject({
     features: v.array(featureNameSchema),
     packages: v.optional(v.array(v.strictObject({
         name: nonEmptyString,
-        path: nonEmptyString
-    })))
+        path: nonEmptyString,
+    }))),
 });
 function formatIssuePath(issue) {
     if (!issue.path || issue.path.length === 0) {
@@ -223,7 +119,7 @@ function formatIssuePath(issue) {
 function shapeIssues(issues) {
     return issues.map((issue) => ({
         path: formatIssuePath(issue),
-        message: issue.message
+        message: issue.message,
     }));
 }
 function duplicateIssues(values, path) {
@@ -237,7 +133,7 @@ function duplicateIssues(values, path) {
     }
     return [...duplicates].map((value) => ({
         path,
-        message: `Duplicate value: ${value}`
+        message: `Duplicate value: ${value}`,
     }));
 }
 function generationSupportIssue(preset, path) {
@@ -246,7 +142,13 @@ function generationSupportIssue(preset, path) {
     }
     return {
         path,
-        message: `Preset ${preset.name} is not supported for generation in this version`
+        message: `Preset ${preset.name} is not supported for generation in this version`,
+    };
+}
+function unsupportedSinglePackageProjectShapeIssue(path) {
+    return {
+        path,
+        message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
     };
 }
 export function validatePresetFile(input) {
@@ -257,8 +159,11 @@ export function validatePresetFile(input) {
     const semanticIssues = [
         ...duplicateIssues(result.output.supportedPackageManagers, "$.supportedPackageManagers"),
         ...duplicateIssues(result.output.supportedProjectKinds, "$.supportedProjectKinds"),
-        ...duplicateIssues(result.output.features, "$.features")
+        ...duplicateIssues(result.output.features, "$.features"),
     ];
+    if (result.output.supportedProjectKinds.includes("single-package")) {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.supportedProjectKinds"));
+    }
     const builtInPreset = findBuiltInPreset(result.output.name);
     const unsupportedGeneration = builtInPreset
         ? generationSupportIssue(builtInPreset, "$.name")
@@ -282,12 +187,15 @@ export function validateProjectBlueprint(input) {
     const blueprint = result.output;
     const preset = findBuiltInPreset(blueprint.preset);
     const semanticIssues = [
-        ...duplicateIssues(blueprint.features, "$.features")
+        ...duplicateIssues(blueprint.features, "$.features"),
     ];
+    if (blueprint.projectKind === "single-package") {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.projectKind"));
+    }
     if (!preset) {
         semanticIssues.push({
             path: "$.preset",
-            message: `Unknown built-in preset: ${blueprint.preset}`
+            message: `Unknown built-in preset: ${blueprint.preset}`,
         });
     }
     else {
@@ -299,19 +207,20 @@ export function validateProjectBlueprint(input) {
             !preset.supportedPackageManagers.includes(blueprint.packageManager)) {
             semanticIssues.push({
                 path: "$.packageManager",
-                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`
+                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`,
             });
         }
-        if (!blueprint.packageManager && preset.supportedPackageManagers.length > 0) {
+        if (!blueprint.packageManager &&
+            preset.supportedPackageManagers.length > 0) {
             semanticIssues.push({
                 path: "$.packageManager",
-                message: `packageManager is required by preset ${preset.name}`
+                message: `packageManager is required by preset ${preset.name}`,
             });
         }
         if (!preset.supportedProjectKinds.includes(blueprint.projectKind)) {
             semanticIssues.push({
                 path: "$.projectKind",
-                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`
+                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`,
             });
         }
         const supportedFeatures = new Set(preset.features);
@@ -319,18 +228,12 @@ export function validateProjectBlueprint(input) {
             if (!supportedFeatures.has(feature)) {
                 semanticIssues.push({
                     path: "$.features",
-                    message: `${feature} is not supported by preset ${preset.name}`
+                    message: `${feature} is not supported by preset ${preset.name}`,
                 });
             }
         }
     }
     if (blueprint.packages) {
-        if (blueprint.projectKind === "single-package" && blueprint.packages.length > 1) {
-            semanticIssues.push({
-                path: "$.packages",
-                message: "single-package blueprints support exactly one package"
-            });
-        }
         semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"));
     }
     if (semanticIssues.length > 0) {

package/dist/src/dependency-catalog.d.ts

@@ -0,0 +1,18 @@
+export type TemplateDependencyCatalog = Record<string, string>;
+export type GeneratedDependencyCatalogOptions = {
+    readonly dependencies: readonly string[];
+    readonly packages?: readonly string[];
+    readonly allowBuilds?: Record<string, boolean>;
+};
+export type GeneratedPackageManifestDependencies = {
+    readonly dependencies?: Record<string, string>;
+    readonly devDependencies?: Record<string, string>;
+    readonly optionalDependencies?: Record<string, string>;
+    readonly peerDependencies?: Record<string, string>;
+};
+export declare function loadTemplateDependencyCatalog(): TemplateDependencyCatalog;
+export declare function selectTemplateDependencyCatalogEntries(dependencies: readonly string[], catalog?: TemplateDependencyCatalog): TemplateDependencyCatalog;
+export declare function collectGeneratedManifestCatalogDependencies(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
+export declare function collectGeneratedManifestCatalogReferences(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
+export declare function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml: string, dependencies: readonly string[], templateCatalog?: TemplateDependencyCatalog): string;
+export declare function renderGeneratedPnpmWorkspaceYaml(options: GeneratedDependencyCatalogOptions): string;