@ykdz/template 0.0.6 → 0.0.8

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;

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

@@ -1,11 +1,9 @@
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import * as v from "valibot";
 import { loadTemplateDependencyCatalog, } from "./dependency-catalog.js";
 import { PackageAdditionSupport } from "./package-addition-support.js";
 import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, } from "./projection-capabilities.js";
-import { packageTemplateRoot } from "./runtime-paths.js";
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",
@@ -402,34 +400,34 @@ function formatIssuePath(issue) {
     if (!issue.path || issue.path.length === 0) {
         return "$";
     }
-    return issue.path.reduce((path, item) => {
+    return issue.path.reduce((issuePath, item) => {
         if (typeof item.key === "number") {
-            return `${path}[${item.key}]`;
+            return `${issuePath}[${item.key}]`;
         }
-        return `${path}.${String(item.key)}`;
+        return `${issuePath}.${String(item.key)}`;
     }, "$");
 }
 function shapeIssues(issues) {
     return issues.map((issue) => {
-        const path = formatIssuePath(issue);
-        const missingPresetMetadata = path.match(/^\$\.presets\[\d+\]\.(.+)$/);
+        const validationPath = formatIssuePath(issue);
+        const missingPresetMetadata = validationPath.match(/^\$\.presets\[\d+\]\.(.+)$/);
         if (missingPresetMetadata && issue.message.includes("received undefined")) {
             return {
-                path,
+                path: validationPath,
                 message: `Preset metadata is missing required field: ${missingPresetMetadata[1]}`,
             };
         }
         if (issue.message.startsWith("Invalid key:") &&
-            /\.(body|content|text)$/.test(path)) {
-            const key = path.split(".").at(-1);
+            /\.(body|content|text)$/.test(validationPath)) {
+            const key = validationPath.split(".").at(-1);
             return {
-                path,
+                path: validationPath,
                 message: `Preset Source Manifests must reference Generated Repository file bodies by path, not inline ${key}`,
             };
         }
         return {
-            path,
-            message: path.match(/^\$\.presets\[\d+\]\.packageAdditionSupport$/)
+            path: validationPath,
+            message: validationPath.match(/^\$\.presets\[\d+\]\.packageAdditionSupport$/)
                 ? "Package Addition Support must be one of: supported, unsupported"
                 : issue.message,
         };
@@ -449,7 +447,7 @@ function duplicatePresetNameIssues(presets) {
         message: `Duplicate Preset name: ${name}`,
     }));
 }
-function duplicateValueIssues(values, path) {
+function duplicateValueIssues(values, validationPath) {
     const seen = new Set();
     const duplicates = new Set();
     for (const value of values) {
@@ -459,7 +457,7 @@ function duplicateValueIssues(values, path) {
         seen.add(value);
     }
     return [...duplicates].map((value) => ({
-        path,
+        path: validationPath,
         message: `Duplicate value: ${value}`,
     }));
 }
@@ -921,20 +919,6 @@ export function loadPresetSourceManifestFile(filePath) {
     }
     return result.value;
 }
-export function loadBuiltInPresetSourceManifest() {
-    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-    const filePath = packageTemplateRoot(moduleDir, "preset-source.json");
-    const result = validateBuiltInPresetSourceManifest(JSON.parse(readFileSync(filePath, "utf8")), { sourceRoot: path.dirname(filePath) });
-    if (!result.ok) {
-        throw new Error(`Built-in Preset Source Manifest is invalid:\n${result.issues
-            .map((issue) => `  - ${issue.path}: ${issue.message}`)
-            .join("\n")}`);
-    }
-    return result.value;
-}
 export function findPresetSourceManifestPreset(manifest, presetName) {
     return manifest.presets.find((preset) => preset.name === presetName);
 }
-export function findBuiltInPresetSourceManifestPreset(presetName) {
-    return findPresetSourceManifestPreset(loadBuiltInPresetSourceManifest(), presetName);
-}

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

@@ -46,6 +46,12 @@ export type ProjectionCapabilityDeclaration = WorkspaceLibraryPackageCapabilityD
 export type PresetProjectionDeclaration = {
     readonly capabilities: readonly ProjectionCapabilityDeclaration[];
 };
+export type ProjectionSourcePreset = "hono-api" | "rust-bin" | "ts-lib" | "vue-app" | "vue-hono-app";
+export type PresetProjectionSourceRoots = {
+    readonly preset: (sourcePreset: ProjectionSourcePreset) => string;
+    readonly sharedOxc: () => string;
+    readonly sharedDevcontainer: () => string;
+};
 export declare function validateProjectionCapabilities(input: unknown): ValidationResult<PresetProjectionDeclaration>;
 export declare function projectionCapabilityIssues(presets: readonly PresetSourceManifestPreset[]): ValidationIssue[];
 export declare function normalizePresetProjectionDeclaration(declaration: PresetProjectionDeclaration): PresetProjectionDeclaration;
@@ -53,15 +59,17 @@ export declare function interpretPresetProjectionDeclaration(options: {
     readonly preset: PresetSourceManifestPreset;
     readonly declaration: PresetProjectionDeclaration;
     readonly context: GenerationContext;
+    readonly sourceRoots: PresetProjectionSourceRoots;
 }): PresetProjectionPlan;
 export declare function blueprintForPresetSourcePreset(preset: PresetSourceManifestPreset, options?: PresetBlueprintOptions): ProjectBlueprint;
 export declare function projectPresetSourcePreset(options: {
     readonly preset: PresetSourceManifestPreset;
     readonly context: GenerationContext;
+    readonly sourceRoots: PresetProjectionSourceRoots;
 }): PresetProjectionPlan;
 export declare function planPresetSourcePackageAddition(options: {
     readonly preset: PresetSourceManifestPreset;
     readonly addition: PresetPackageAdditionOptions;
+    readonly sourceRoots: PresetProjectionSourceRoots;
 }): Promise<PresetPackageAdditionPlan>;
-export declare function defaultPackagePathForPresetSourcePackageAddition(preset: PresetSourceManifestPreset, packageLeafName: string): string;
-export declare function loadBuiltInPresetProjectionDeclaration(presetName: string): PresetProjectionDeclaration;
+export declare function defaultPackagePathForPresetSourcePackageAddition(preset: PresetSourceManifestPreset, packageLeafName: string, sourceRoots: PresetProjectionSourceRoots): string;

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

@@ -1,13 +1,10 @@
-import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderGeneratedPnpmWorkspaceYaml, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
 import { editorCustomizationForCapabilities, } from "./editor-customization.js";
 import { renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
 import { packageManifestExposureFields, planPackageLinks, } from "./package-linking.js";
-import { packageTemplateRoot } from "./runtime-paths.js";
 const projectionCapabilityKinds = [
     "workspace-library-package",
     "workspace-node-packages",
@@ -26,10 +23,6 @@ const workspacePackageBoundary = {
     kind: "package-boundary",
     path: ".",
 };
-const workspacePackageCollectionBoundary = {
-    kind: "package-boundary",
-    path: "packages/*",
-};
 const requiredPlanCapabilityProviders = [
     {
         flag: "rootCheck",
@@ -83,7 +76,7 @@ const capabilityInterpreters = {
         kind: "workspace-library-package",
         contribute({ capability, state }) {
             state.package = capability;
-            state.sourceRoot = templateSourceRoot(capability.packageSourcePreset);
+            state.sourceRoot = templateSourceRoot(state, capability.packageSourcePreset);
             state.packageDependencies.add("valibot");
             state.operationFactories.push(workspaceLibraryPackageOperations);
         },
@@ -92,7 +85,7 @@ const capabilityInterpreters = {
         kind: "workspace-node-packages",
         contribute({ capability, state }) {
             state.nodeWorkspace = capability;
-            state.sourceRoot = templateSourceRootForPreset(sourceRootPreset(capability));
+            state.sourceRoot = templateSourceRootForPreset(state, sourceRootPreset(capability));
             state.operationFactories.push(workspaceNodePackagesOperations);
             if (capability.packages.length > 1) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
@@ -112,8 +105,9 @@ const capabilityInterpreters = {
         kind: "rust-binary-workspace",
         contribute({ capability, state }) {
             state.rustWorkspace = capability;
-            state.sourceRoot = templateSourceRootForPreset("rust-bin");
-            state.sourceRoots.sharedDevcontainer = sharedDevcontainerSourceRoot();
+            state.sourceRoot = templateSourceRootForPreset(state, "rust-bin");
+            state.sourceRoots.sharedDevcontainer =
+                state.projectionSourceRoots.sharedDevcontainer();
             state.rootCheckComponents.push({
                 kind: "turbo-package-check",
                 owner: workspaceGlobBoundary(capability.workspacePackageGlob),
@@ -186,7 +180,7 @@ const capabilityInterpreters = {
     "oxc-format-lint": {
         kind: "oxc-format-lint",
         contribute({ state }) {
-            state.sourceRoots.sharedOxc = sharedOxcSourceRoot();
+            state.sourceRoots.sharedOxc = state.projectionSourceRoots.sharedOxc();
             state.rootCheckComponents.unshift({
                 kind: "oxc-format-check",
                 owner: strictTypescriptRootBoundary,
@@ -234,7 +228,8 @@ const capabilityInterpreters = {
     "node-pnpm-devcontainer": {
         kind: "node-pnpm-devcontainer",
         contribute({ state }) {
-            state.sourceRoots.sharedDevcontainer = sharedDevcontainerSourceRoot();
+            state.sourceRoots.sharedDevcontainer =
+                state.projectionSourceRoots.sharedDevcontainer();
             state.flags.devcontainer = true;
             state.operationFactories.push(nodePnpmDevcontainerOperations);
         },
@@ -361,7 +356,7 @@ export function interpretPresetProjectionDeclaration(options) {
             .map((issue) => `  - ${issue.path}: ${issue.message}`)
             .join("\n")}`);
     }
-    const state = createProjectionCompositionState();
+    const state = createProjectionCompositionState(options.sourceRoots);
     for (const capability of validation.value.capabilities) {
         capabilityInterpreters[capability.kind].contribute({
             capability: capability,
@@ -437,13 +432,14 @@ export function projectPresetSourcePreset(options) {
         preset: options.preset,
         declaration: options.preset.projection,
         context: options.context,
+        sourceRoots: options.sourceRoots,
     });
 }
 export async function planPresetSourcePackageAddition(options) {
     if (options.preset.projection === undefined) {
         throw new Error(`Preset ${options.preset.name} declares Package Addition support but has no Projection Declaration`);
     }
-    const state = stateForProjectionDeclaration(options.preset.projection);
+    const state = stateForProjectionDeclaration(options.preset.projection, options.sourceRoots);
     const additionCapability = packageAdditionCapabilityForState(options.preset.name, state);
     return {
         packagePath: options.addition.packagePath,
@@ -451,7 +447,7 @@ export async function planPresetSourcePackageAddition(options) {
         workspaceMembershipGlob: `${packageCollectionFromPackagePath(options.addition.packagePath)}/*`,
         packageRole: additionCapability.packageRole,
         packageSourcePreset: additionCapability.packageSourcePreset,
-        sourceRoot: templateSourceRootForPreset(additionCapability.sourcePreset),
+        sourceRoot: templateSourceRootForPreset(state, additionCapability.sourcePreset),
         sourceRoots: state.sourceRoots,
         operations: [
             ...packageAdditionOperationsForCapability({
@@ -475,34 +471,17 @@ export async function planPresetSourcePackageAddition(options) {
         ],
     };
 }
-export function defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName) {
+export function defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName, sourceRoots) {
     if (preset.projection === undefined) {
         throw new Error(`Preset ${preset.name} declares Package Addition support but has no Projection Declaration`);
     }
-    const state = stateForProjectionDeclaration(preset.projection);
+    const state = stateForProjectionDeclaration(preset.projection, sourceRoots);
     const additionCapability = packageAdditionCapabilityForState(preset.name, state);
     return `${packageCollection(additionCapability.workspacePackageGlob)}/${packageLeafName}`;
 }
-export function loadBuiltInPresetProjectionDeclaration(presetName) {
-    const manifestPath = path.join(packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url))), "preset-source.json");
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-    if (!isRecord(manifest) || !Array.isArray(manifest.presets)) {
-        throw new Error("Built-in Preset Source Manifest must declare presets");
-    }
-    const preset = manifest.presets.find((candidate) => isRecord(candidate) && candidate.name === presetName);
-    if (!isRecord(preset) || preset.projection === undefined) {
-        throw new Error(`Built-in Preset ${presetName} must declare a Projection Declaration`);
-    }
-    const result = validateProjectionCapabilities(preset.projection);
-    if (!result.ok) {
-        throw new Error(`Built-in Preset ${presetName} Projection Declaration is invalid:\n${result.issues
-            .map((issue) => `  - ${issue.path}: ${issue.message}`)
-            .join("\n")}`);
-    }
-    return result.value;
-}
-function createProjectionCompositionState() {
+function createProjectionCompositionState(sourceRoots) {
     return {
+        projectionSourceRoots: sourceRoots,
         sourceRoots: {},
         rootCheckComponents: [],
         rootCheckEnvironmentNeeds: [],
@@ -860,14 +839,14 @@ function blueprintPackagesForCapabilities(capabilities, packageScope, projectNam
         return [];
     });
 }
-function stateForProjectionDeclaration(declaration) {
+function stateForProjectionDeclaration(declaration, sourceRoots) {
     const validation = validateProjectionCapabilities(declaration);
     if (!validation.ok) {
         throw new Error(`Projection Declaration is invalid:\n${validation.issues
             .map((issue) => `  - ${issue.path}: ${issue.message}`)
             .join("\n")}`);
     }
-    const state = createProjectionCompositionState();
+    const state = createProjectionCompositionState(sourceRoots);
     for (const capability of validation.value.capabilities) {
         capabilityInterpreters[capability.kind].contribute({
             capability: capability,
@@ -2193,15 +2172,9 @@ function githubMaintenanceOperations() {
         },
     ];
 }
-function templateSourceRoot(sourcePreset) {
-    return templateSourceRootForPreset(sourcePreset);
-}
-function templateSourceRootForPreset(sourcePreset) {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), sourcePreset);
-}
-function sharedOxcSourceRoot() {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "oxc");
+function templateSourceRoot(state, sourcePreset) {
+    return templateSourceRootForPreset(state, sourcePreset);
 }
-function sharedDevcontainerSourceRoot() {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "devcontainer");
+function templateSourceRootForPreset(state, sourcePreset) {
+    return state.projectionSourceRoots.preset(sourcePreset);
 }

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

@@ -380,7 +380,9 @@ async function copyGeneratedFile(from, to) {
     }
     catch (error) {
         if (isNodeError(error) && error.code === "EEXIST") {
-            throw new Error(`Refusing to overwrite existing file: ${to}`);
+            throw new Error(`Refusing to overwrite existing file: ${to}`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -394,7 +396,9 @@ async function writeGeneratedFile(to, text, overwrite = false) {
     }
     catch (error) {
         if (isNodeError(error) && error.code === "EEXIST") {
-            throw new Error(`Refusing to overwrite existing file: ${to}`);
+            throw new Error(`Refusing to overwrite existing file: ${to}`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -447,7 +451,9 @@ async function commitStagedProject(stagingRoot, targetRoot) {
                 // The target disappeared between the emptiness check and commit.
             }
             else if (isNodeError(error) && error.code === "ENOTEMPTY") {
-                throw new Error(`Target directory is not empty: ${targetRoot}`);
+                throw new Error(`Target directory is not empty: ${targetRoot}`, {
+                    cause: error,
+                });
             }
             else {
                 throw error;
@@ -460,7 +466,9 @@ async function commitStagedProject(stagingRoot, targetRoot) {
     catch (error) {
         if (isNodeError(error) &&
             ["EEXIST", "ENOTEMPTY", "ENOTDIR", "EISDIR"].includes(error.code ?? "")) {
-            throw new Error(`Refusing to overwrite existing target: ${targetRoot}`);
+            throw new Error(`Refusing to overwrite existing target: ${targetRoot}`, {
+                cause: error,
+            });
         }
         throw error;
     }