@ykdz/template 0.0.7 → 0.0.8

package/node_modules/@ykdz/template-builtin-source/dist/templates/vue-hono-app/projection.js

@@ -0,0 +1,203 @@
+import path from "node:path";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject } from "@ykdz/template-core/renderer";
+export const vueHonoAppPresetMetadata = {
+    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"],
+    packageAdditionSupport: PackageAdditionSupport.Unsupported,
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const rootBoundary = {
+    kind: "workspace-orchestration",
+    path: ".",
+};
+const apiPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const webPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const workspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "apps/*",
+};
+const webWorkspaceBoundary = {
+    kind: "package-boundary",
+    path: "apps/web",
+};
+function honoApiCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+    ];
+}
+function vueWebCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+        { kind: "e2e-test", owner },
+    ];
+}
+function nodeFixComponents(owner) {
+    return [
+        { kind: "oxc-format-write", owner },
+        { kind: "oxc-lint-fix", owner },
+    ];
+}
+function planVueHonoRootChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: rootBoundary },
+            { kind: "oxc-lint", owner: rootBoundary },
+            { kind: "typescript-typecheck", owner: rootBoundary },
+            { kind: "turbo-package-typecheck", owner: workspacePackageBoundary },
+            { kind: "turbo-package-build", owner: workspacePackageBoundary },
+            { kind: "turbo-package-test", owner: workspacePackageBoundary },
+            { kind: "turbo-package-e2e-test", owner: workspacePackageBoundary },
+            { kind: "turbo-package-check", owner: workspacePackageBoundary },
+        ],
+        environmentNeeds: [
+            {
+                kind: "playwright-browser-assets",
+                browser: "chromium",
+                owner: webWorkspaceBoundary,
+            },
+        ],
+    };
+}
+function planVueHonoRootFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: rootBoundary },
+            { kind: "oxc-lint-fix", owner: rootBoundary },
+            { kind: "turbo-package-fix", owner: workspacePackageBoundary },
+        ],
+    };
+}
+function planVueHonoApiChecks() {
+    return {
+        components: [...honoApiCheckComponents(apiPackageBoundary)],
+        environmentNeeds: [],
+    };
+}
+function planVueHonoWebChecks() {
+    return {
+        components: [...vueWebCheckComponents(webPackageBoundary)],
+        environmentNeeds: [],
+    };
+}
+function planVueHonoPackageFixes(owner) {
+    return {
+        components: [...nodeFixComponents(owner)],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function scopedPackageName(packageScope, leaf) {
+    return `@${packageScope}/${leaf}`;
+}
+export function vueHonoAppBlueprint(options) {
+    const packageScope = packageScopeFromOptions(options);
+    return {
+        schemaVersion: 1,
+        preset: "vue-hono-app",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...vueHonoAppPresetMetadata.features],
+        packages: [
+            { name: scopedPackageName(packageScope, "web"), path: "apps/web" },
+            { name: scopedPackageName(packageScope, "api"), path: "apps/api" },
+        ],
+    };
+}
+export function projectVueHonoRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planVueHonoRootChecks()),
+        dev: "turbo run dev --parallel",
+        fix: renderFixCommand(planVueHonoRootFixes()),
+        "format:check": "oxfmt --check --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        "format:write": "oxfmt --write --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        lint: "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --deny-warnings",
+        "lint:fix": "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix --deny-warnings",
+        typecheck: "tsc -p tsconfig.config.json --noEmit",
+    };
+}
+export function projectVueHonoApiPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+        check: renderRootCheckCommand(planVueHonoApiChecks()),
+        dev: "tsx watch src/server.ts",
+        fix: renderFixCommand(planVueHonoPackageFixes(apiPackageBoundary)),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
+        start: "node dist/server.js",
+        test: "vitest run",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
+export function projectVueHonoWebPackageScripts() {
+    return {
+        build: "vite build",
+        check: renderRootCheckCommand(planVueHonoWebChecks()),
+        dev: "vite",
+        fix: renderFixCommand(planVueHonoPackageFixes(webPackageBoundary)),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
+        preview: "vite preview",
+        test: "vitest run",
+        "test:e2e": "pnpm run build && playwright test",
+        typecheck: "vue-tsc --build",
+    };
+}
+export const vueHonoAppPresetProjection = {
+    metadata: vueHonoAppPresetMetadata,
+    blueprint: vueHonoAppBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: vueHonoAppPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("vue-hono-app"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@ykdz/template-builtin-source",
+  "version": "0.0.8",
+  "private": true,
+  "files": [
+    "dist",
+    "templates",
+    "!templates/*.tmp",
+    "!templates/registry.ts",
+    "!templates/projection-plans.ts",
+    "!templates/*/projection.ts",
+    "!templates/shared/oxc/tsconfig.json",
+    "!templates/**/node_modules"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./registry": {
+      "types": "./dist/templates/registry.d.ts",
+      "default": "./dist/templates/registry.js"
+    },
+    "./projection-plans": {
+      "types": "./dist/templates/projection-plans.d.ts",
+      "default": "./dist/templates/projection-plans.js"
+    },
+    "./templates/*": {
+      "types": "./dist/templates/*.d.ts",
+      "default": "./dist/templates/*.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@ykdz/template-core": "workspace:*",
+    "typescript": "catalog:",
+    "valibot": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:"
+  }
+}

package/{templates → node_modules/@ykdz/template-builtin-source/templates}/shared/oxc/node/oxlint.config.ts

@@ -6,4 +6,7 @@ export default defineConfig({
     suspicious: "error",
   },
   plugins: ["typescript", "oxc"],
+  rules: {
+    "no-unused-vars": "error",
+  },
 });

package/{templates → node_modules/@ykdz/template-builtin-source/templates}/shared/oxc/vue/oxlint.config.ts

@@ -6,4 +6,7 @@ export default defineConfig({
     suspicious: "error",
   },
   plugins: ["typescript", "oxc", "vue"],
+  rules: {
+    "no-unused-vars": "error",
+  },
 });

package/{dist/src → node_modules/@ykdz/template-core/dist}/declarations.d.ts

@@ -38,7 +38,6 @@ export type ProjectBlueprint = {
     packages?: ProjectPackage[];
     packageLinkIntents?: PackageLinkIntent[];
 };
-export declare const builtInPresets: readonly BuiltInPreset[];
 export declare const presetFileJsonSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://ykdz.dev/schemas/project-kit/preset-file.schema.json";
@@ -195,6 +194,10 @@ export type ValidationResult<T> = {
     ok: false;
     issues: ValidationIssue[];
 };
-export declare function validatePresetFile(input: unknown): ValidationResult<PresetFile>;
-export declare function findBuiltInPreset(name: string): BuiltInPreset | undefined;
-export declare function validateProjectBlueprint(input: unknown): ValidationResult<ProjectBlueprint>;
+export type PresetCatalogValidationOptions = {
+    readonly presets?: readonly BuiltInPreset[];
+    readonly presetLabel?: string;
+};
+export declare function validatePresetFile(input: unknown, options?: PresetCatalogValidationOptions): ValidationResult<PresetFile>;
+export declare function findPreset(presets: readonly BuiltInPreset[], name: string): BuiltInPreset | undefined;
+export declare function validateProjectBlueprint(input: unknown, options?: PresetCatalogValidationOptions): ValidationResult<ProjectBlueprint>;

package/{dist/src → node_modules/@ykdz/template-core/dist}/declarations.js

@@ -1,6 +1,4 @@
 import * as v from "valibot";
-import { loadBuiltInPresetSourceManifest } from "./preset-source.js";
-export const builtInPresets = loadBuiltInPresetSourceManifest().presets;
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",
@@ -180,7 +178,7 @@ function unsupportedSinglePackageProjectShapeIssue(path) {
         message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
     };
 }
-export function validatePresetFile(input) {
+export function validatePresetFile(input, options = {}) {
     const result = v.safeParse(presetFileSchema, input);
     if (!result.success) {
         return { ok: false, issues: shapeIssues(result.issues) };
@@ -193,9 +191,9 @@ export function validatePresetFile(input) {
     if (result.output.supportedProjectKinds.includes("single-package")) {
         semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.supportedProjectKinds"));
     }
-    const builtInPreset = findBuiltInPreset(result.output.name);
-    const unsupportedGeneration = builtInPreset
-        ? generationSupportIssue(builtInPreset, "$.name")
+    const catalogPreset = findPreset(options.presets ?? [], result.output.name);
+    const unsupportedGeneration = catalogPreset
+        ? generationSupportIssue(catalogPreset, "$.name")
         : undefined;
     if (unsupportedGeneration) {
         semanticIssues.push(unsupportedGeneration);
@@ -205,29 +203,29 @@ export function validatePresetFile(input) {
     }
     return { ok: true, value: result.output };
 }
-export function findBuiltInPreset(name) {
-    return builtInPresets.find((preset) => preset.name === name);
+export function findPreset(presets, name) {
+    return presets.find((preset) => preset.name === name);
 }
-export function validateProjectBlueprint(input) {
+export function validateProjectBlueprint(input, options = {}) {
     const result = v.safeParse(projectBlueprintSchema, input);
     if (!result.success) {
         return { ok: false, issues: shapeIssues(result.issues) };
     }
     const blueprint = result.output;
-    const preset = findBuiltInPreset(blueprint.preset);
+    const preset = findPreset(options.presets ?? [], blueprint.preset);
     const semanticIssues = [
         ...duplicateIssues(blueprint.features, "$.features"),
     ];
     if (blueprint.projectKind === "single-package") {
         semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.projectKind"));
     }
-    if (!preset) {
+    if (options.presets && !preset) {
         semanticIssues.push({
             path: "$.preset",
-            message: `Unknown built-in preset: ${blueprint.preset}`,
+            message: `Unknown ${options.presetLabel ?? "built-in"} preset: ${blueprint.preset}`,
         });
     }
-    else {
+    else if (preset) {
         const unsupportedGeneration = generationSupportIssue(preset, "$.preset");
         if (unsupportedGeneration) {
             semanticIssues.push(unsupportedGeneration);

package/{dist/src → node_modules/@ykdz/template-core/dist}/dependency-catalog.js

@@ -4,8 +4,10 @@ import { fileURLToPath } from "node:url";
 function templateRepositoryRoot() {
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
+        moduleDir,
         path.resolve(moduleDir, ".."),
         path.resolve(moduleDir, "..", ".."),
+        path.resolve(moduleDir, "..", "..", ".."),
     ];
     return (candidates.find((candidate) => existsSync(path.join(candidate, "pnpm-workspace.yaml"))) ?? candidates[0]);
 }

package/{dist/src → node_modules/@ykdz/template-core/dist}/editor-customization.js

@@ -15,10 +15,12 @@ const defaultOxcConfigPaths = {
 const declarations = loadEditorCustomizationDeclarations();
 function editorCustomizationDeclarationPath() {
     const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
-    const relativeDeclarationPath = "templates/shared/editor-customization/capabilities.json";
+    const relativeDeclarationPath = "builtin-source/templates/shared/editor-customization/capabilities.json";
     const candidates = [
         path.resolve(moduleDirectory, "..", relativeDeclarationPath),
         path.resolve(moduleDirectory, "..", "..", relativeDeclarationPath),
+        path.resolve(moduleDirectory, "..", "..", "template-builtin-source", "templates", "shared", "editor-customization", "capabilities.json"),
+        path.resolve(moduleDirectory, "..", "..", "..", "packages", relativeDeclarationPath),
     ];
     const declarationPath = candidates.find((candidate) => existsSync(candidate));
     if (!declarationPath) {

package/{dist/src → node_modules/@ykdz/template-core/dist}/generated-scenarios.d.ts

@@ -1,4 +1,5 @@
 import type { PresetSourceManifest } from "./preset-source.js";
+import { type PresetProjectionSourceRoots } from "./projection-capabilities.js";
 export type GeneratedScenarioSet = "init" | "package-addition-matrix";
 export type GeneratedScenario = {
     readonly set: GeneratedScenarioSet;
@@ -38,6 +39,7 @@ export type GeneratedScenarioReporter = {
 export type GeneratedScenarioRunnerOptions = {
     readonly repoRoot: string;
     readonly cliPath: string;
+    readonly projectionSourceRoots: PresetProjectionSourceRoots;
     readonly runCommand?: GeneratedScenarioCommandRunner;
     readonly reporter?: GeneratedScenarioReporter;
     readonly deterministicToolchainEnv?: Record<string, string>;

package/{dist/src → node_modules/@ykdz/template-core/dist}/generated-scenarios.js

@@ -10,6 +10,12 @@ const defaultDeterministicToolchainEnv = {
     TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
 };
 const defaultFixtureConcurrency = 2;
+function cliSourceExecutionEnv(options, env = {}) {
+    return {
+        ...env,
+        TSX_TSCONFIG_PATH: path.join(options.repoRoot, "tsconfig.json"),
+    };
+}
 export function createExclusiveLock() {
     let tail = Promise.resolve();
     return {
@@ -50,7 +56,7 @@ export function generatedScenarioLabel(scenario) {
     }
     return `${scenario.basePreset} + ${scenario.addedPreset}`;
 }
-function scenario(set, input) {
+function createGeneratedScenario(set, input) {
     return {
         set,
         basePreset: input.basePreset,
@@ -65,11 +71,11 @@ export function selectGeneratedScenarios(manifest, set) {
     if (!contract) {
         throw new Error(`Preset Source ${manifest.name} does not declare a Fixture Matrix Contract`);
     }
-    const initScenarios = contract.initSupport.map((support) => scenario(set, { basePreset: support.preset }));
+    const initScenarios = contract.initSupport.map((support) => createGeneratedScenario(set, { basePreset: support.preset }));
     if (set === "init") {
         return { runnable: initScenarios, skipped: [] };
     }
-    const matrixScenarios = contract.supportedCombinations.map((combination) => scenario(set, {
+    const matrixScenarios = contract.supportedCombinations.map((combination) => createGeneratedScenario(set, {
         basePreset: combination.basePreset,
         addedPreset: combination.addedPreset,
         linkFrom: combination.linkFrom,
@@ -115,7 +121,7 @@ async function generateScenario(scenario, workspace, options) {
         scenario.basePreset,
         "--yes",
     ], options.repoRoot, {
-        env: options.deterministicToolchainEnv,
+        env: cliSourceExecutionEnv(options, options.deterministicToolchainEnv),
         logPrefix: scenario.label,
     });
     return projectDir;
@@ -137,7 +143,10 @@ async function applyPackageAddition(manifest, scenario, projectDir, options) {
         "--name",
         packageLeafName,
         ...linkFromArgs(scenario.linkFrom ?? []),
-    ], projectDir, { logPrefix: scenario.label });
+    ], projectDir, {
+        env: cliSourceExecutionEnv(options),
+        logPrefix: scenario.label,
+    });
     await assertLinkedConsumerSourcesUnchanged(projectDir, beforeConsumerSources);
     return readAddedPackagePath(projectDir, packageLeafName);
 }
@@ -193,6 +202,7 @@ function projectionPlanForPreset(presetName, projectDir, manifest, options, pack
     });
     return projectPresetSourcePreset({
         preset,
+        sourceRoots: options.projectionSourceRoots,
         context: assembleGenerationContext({
             targetDir: projectDir,
             blueprint,
@@ -312,6 +322,7 @@ function normalizeRunnerOptions(options) {
     return {
         repoRoot: options.repoRoot,
         cliPath: options.cliPath,
+        projectionSourceRoots: options.projectionSourceRoots,
         runCommand: options.runCommand ?? defaultGeneratedScenarioCommandRunner,
         reporter: options.reporter ?? {
             info: console.log,

package/node_modules/@ykdz/template-core/dist/package-addition.d.ts

@@ -0,0 +1,12 @@
+import { type PresetSourceManifest } from "./preset-source.js";
+import { type PresetProjectionSourceRoots } from "./projection-capabilities.js";
+export type AddPackageOptions = {
+    cwd: string;
+    preset: string;
+    name: string;
+    path?: string;
+    linkFrom?: readonly string[];
+    presetSourceManifest: PresetSourceManifest;
+    projectionSourceRoots: PresetProjectionSourceRoots;
+};
+export declare function addPackage(options: AddPackageOptions): Promise<void>;

package/{dist/src → node_modules/@ykdz/template-core/dist}/package-addition.js

@@ -4,7 +4,7 @@ import { validateProjectBlueprint, } from "./declarations.js";
 import { collectGeneratedManifestCatalogReferences, pnpmWorkspaceYamlWithCatalogDependencies, } from "./dependency-catalog.js";
 import { PackageAdditionSupport } from "./package-addition-support.js";
 import { assertTypeScriptPackageBoundaryForLinkIntent, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
-import { findBuiltInPresetSourceManifestPreset, loadBuiltInPresetSourceManifest, } from "./preset-source.js";
+import { findPresetSourceManifestPreset, } from "./preset-source.js";
 import { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, } from "./projection-capabilities.js";
 import { renderProject } from "./renderer.js";
 function projectNameFromBlueprint(blueprint, fallbackProjectName) {
@@ -75,16 +75,16 @@ function validateExplicitPackagePath(packagePath) {
     }
     return packagePath;
 }
-function supportedPackageAdditionPresetNames() {
-    return loadBuiltInPresetSourceManifest()
-        .presets.filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported)
+function supportedPackageAdditionPresetNames(manifest) {
+    return manifest.presets
+        .filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported)
         .map((preset) => preset.name);
 }
-function formatUnsupportedPackageAdditionPresetError(preset) {
+function formatUnsupportedPackageAdditionPresetError(preset, manifest) {
     return [
         `Preset ${preset} cannot be used for Package Addition.`,
         "It can still initialize a Generated Repository, but it cannot be added to an existing one.",
-        `Supported Package Addition presets: ${supportedPackageAdditionPresetNames().join(", ")}`,
+        `Supported Package Addition presets: ${supportedPackageAdditionPresetNames(manifest).join(", ")}`,
     ].join("\n");
 }
 function assertNoPackageConflict(blueprint, packageName, packagePath) {
@@ -228,7 +228,7 @@ async function readGeneratedWorkspaceBlueprint(root) {
     catch (error) {
         if (error instanceof SyntaxError ||
             (isNodeError(error) && error.code === "ENOENT")) {
-            throw new Error("Package Addition requires a valid .template/blueprint.json");
+            throw new Error("Package Addition requires a valid .template/blueprint.json", { cause: error });
         }
         throw error;
     }
@@ -622,18 +622,19 @@ export async function addPackage(options) {
     const repositoryMetadata = await readGeneratedRepositoryPackageMetadata(root);
     const projectName = projectNameFromBlueprint(blueprint, repositoryMetadata.projectName);
     const packageName = `@${projectName}/${options.name}`;
-    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    const preset = findPresetSourceManifestPreset(options.presetSourceManifest, options.preset);
     if (!preset) {
         throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
     }
     if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
-        throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset));
+        throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset, options.presetSourceManifest));
     }
     const packagePath = options.path
         ? validateExplicitPackagePath(options.path)
-        : defaultPackagePathForPresetSourcePackageAddition(preset, options.name);
+        : defaultPackagePathForPresetSourcePackageAddition(preset, options.name, options.projectionSourceRoots);
     const additionPlan = await planPresetSourcePackageAddition({
         preset,
+        sourceRoots: options.projectionSourceRoots,
         addition: {
             root,
             blueprint,

package/{pnpm-workspace.yaml → node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml}

@@ -1,5 +1,5 @@
 packages:
-  - .
+  - packages/*
 
 catalog:
   "@hono/node-server": ^2.0.6
@@ -10,6 +10,7 @@ catalog:
   "@vitejs/plugin-vue": ^6.0.7
   "@vue/tsconfig": ^0.9.1
   "@vueuse/core": ^14.3.0
+  execa: ^9.6.1
   hono: ^4.12.27
   oxfmt: ^0.57.0
   oxlint: ^1.72.0
@@ -24,6 +25,7 @@ catalog:
   vitest: ^4.1.9
   vue: ^3.5.39
   vue-tsc: ^3.3.6
+  yaml: ^2.9.0
 
 allowBuilds:
   esbuild: true

package/{dist/src → node_modules/@ykdz/template-core/dist}/preset-source.d.ts

@@ -229,7 +229,7 @@ export declare const presetSourceManifestJsonSchema: {
                     readonly features: {
                         readonly type: "array";
                         readonly items: {
-                            readonly enum: ("devcontainer" | "oxc-format-lint" | "cargo-test" | "github-actions" | "dependabot" | "pnpm-catalog" | "strict-typescript" | "root-check" | "fix-command" | "rustfmt-clippy" | "native-binary-release")[];
+                            readonly enum: ("pnpm-catalog" | "oxc-format-lint" | "strict-typescript" | "root-check" | "fix-command" | "devcontainer" | "github-actions" | "dependabot" | "rustfmt-clippy" | "cargo-test" | "native-binary-release")[];
                         };
                         readonly uniqueItems: true;
                     };
@@ -425,6 +425,4 @@ export declare function validatePresetSourceManifest(input: unknown, options?: P
 export declare function validateBuiltInPresetSourceManifest(input: unknown, options?: PresetSourceManifestValidationOptions): ValidationResult<PresetSourceManifest>;
 export declare function manifestReferencedSourceFiles(manifest: PresetSourceManifest, sourceRoot: string): string[];
 export declare function loadPresetSourceManifestFile(filePath: string): PresetSourceManifest;
-export declare function loadBuiltInPresetSourceManifest(): PresetSourceManifest;
 export declare function findPresetSourceManifestPreset(manifest: PresetSourceManifest, presetName: string): PresetSourceManifestPreset | undefined;
-export declare function findBuiltInPresetSourceManifestPreset(presetName: string): PresetSourceManifestPreset | undefined;