@ykdz/template 0.0.7 → 0.0.9

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

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { execa } from "execa";
+import * as v from "valibot";
 import { assembleGenerationContext } from "./generation-context.js";
 import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 import { planNextStepInstructions } from "./next-step-instructions.js";
@@ -10,6 +11,18 @@ const defaultDeterministicToolchainEnv = {
     TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
 };
 const defaultFixtureConcurrency = 2;
+const storedBlueprintSchema = v.object({
+    packages: v.optional(v.array(v.object({
+        name: v.string(),
+        path: v.string(),
+    }))),
+});
+function cliSourceExecutionEnv(options, env = {}) {
+    return {
+        ...env,
+        TSX_TSCONFIG_PATH: path.join(options.repoRoot, "tsconfig.json"),
+    };
+}
 export function createExclusiveLock() {
     let tail = Promise.resolve();
     return {
@@ -50,12 +63,14 @@ export function generatedScenarioLabel(scenario) {
     }
     return `${scenario.basePreset} + ${scenario.addedPreset}`;
 }
-function scenario(set, input) {
+function createGeneratedScenario(set, input) {
     return {
         set,
         basePreset: input.basePreset,
-        addedPreset: input.addedPreset,
-        linkFrom: input.linkFrom ? [...input.linkFrom] : undefined,
+        ...(input.addedPreset === undefined
+            ? {}
+            : { addedPreset: input.addedPreset }),
+        ...(input.linkFrom === undefined ? {} : { linkFrom: [...input.linkFrom] }),
         id: generatedScenarioId(input),
         label: generatedScenarioLabel(input),
     };
@@ -65,14 +80,16 @@ 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,
+        ...(combination.linkFrom === undefined
+            ? {}
+            : { linkFrom: combination.linkFrom }),
     }));
     const skipped = contract.semanticSkips.map((skip) => ({
         set,
@@ -99,7 +116,7 @@ export async function defaultGeneratedScenarioCommandRunner(command, args, cwd,
     console.log(`${prefix}$ ${[command, ...args].join(" ")}`);
     await execa(command, [...args], {
         cwd,
-        env: options.env,
+        ...(options.env === undefined ? {} : { env: options.env }),
         stdio: "inherit",
     });
 }
@@ -115,7 +132,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 +154,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);
 }
@@ -154,7 +174,7 @@ async function linkedConsumerSourceSnapshots(projectDir, packagePaths) {
 async function sourceFileSnapshot(sourceDir, currentDir = sourceDir) {
     const snapshot = {};
     const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
         const entryPath = path.join(currentDir, entry.name);
         if (entry.isDirectory()) {
             Object.assign(snapshot, await sourceFileSnapshot(sourceDir, entryPath));
@@ -175,8 +195,14 @@ async function assertLinkedConsumerSourcesUnchanged(projectDir, beforeSnapshots)
     }
 }
 async function readAddedPackagePath(projectDir, packageLeafName) {
-    const blueprint = JSON.parse(await readFile(path.join(projectDir, ".template", "blueprint.json"), "utf8"));
-    const packageDefinition = blueprint.packages?.find((pkg) => path.basename(pkg.path) === packageLeafName);
+    const input = JSON.parse(await readFile(path.join(projectDir, ".template", "blueprint.json"), "utf8"));
+    const result = v.safeParse(storedBlueprintSchema, input);
+    if (!result.success) {
+        throw new Error(`Generated Repository blueprint is invalid: ${result.issues
+            .map((issue) => issue.message)
+            .join("; ")}`);
+    }
+    const packageDefinition = result.output.packages?.find((pkg) => path.basename(pkg.path) === packageLeafName);
     if (!packageDefinition) {
         throw new Error(`Package Addition fixture did not record package leaf ${packageLeafName}`);
     }
@@ -189,10 +215,11 @@ function projectionPlanForPreset(presetName, projectDir, manifest, options, pack
     }
     const blueprint = blueprintForPresetSourcePreset(preset, {
         targetDir: projectDir,
-        scope: packageScope,
+        ...(packageScope === undefined ? {} : { scope: packageScope }),
     });
     return projectPresetSourcePreset({
         preset,
+        sourceRoots: options.projectionSourceRoots,
         context: assembleGenerationContext({
             targetDir: projectDir,
             blueprint,
@@ -238,6 +265,9 @@ function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackag
 function environmentNeedStep(need, projectDir) {
     const display = renderPlaywrightBrowserInstallCommand(need);
     const [command, ...args] = display.split(" ");
+    if (command === undefined) {
+        throw new Error(`Cannot parse environment setup command: ${display}`);
+    }
     return {
         id: `install-${need.owner.path}-playwright-browsers`,
         command,
@@ -272,7 +302,7 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
         const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
         const runStep = async () => {
             await options.runCommand(step.command, [...step.args], step.cwd, {
-                env,
+                ...(env === undefined ? {} : { env }),
                 logPrefix: scenario.label,
             });
         };
@@ -312,6 +342,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/{dist/src → node_modules/@ykdz/template-core/dist}/generation-context.js

@@ -6,9 +6,14 @@ export function assembleGenerationContext(options) {
             value: path.basename(path.resolve(options.targetDir)),
         },
         preset: options.blueprint.preset,
-        packageManager: options.blueprint.packageManager
-            ? { kind: "PackageManager", value: options.blueprint.packageManager }
-            : undefined,
+        ...(options.blueprint.packageManager
+            ? {
+                packageManager: {
+                    kind: "PackageManager",
+                    value: options.blueprint.packageManager,
+                },
+            }
+            : {}),
         blueprint: options.blueprint,
         toolchain: options.toolchain,
     };

package/{dist/src → node_modules/@ykdz/template-core/dist}/next-step-instructions.js

@@ -73,6 +73,9 @@ function checkEnvironmentInstructions(plan) {
     return plan.checkPlan.environmentNeeds.map((need) => {
         const display = renderPlaywrightBrowserInstallCommand(need);
         const [command, ...args] = display.split(" ");
+        if (command === undefined) {
+            throw new Error(`Cannot parse environment setup command: ${display}`);
+        }
         return {
             id: need.owner.path === "apps/web"
                 ? "install-web-playwright-browsers"

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 | undefined;
+    linkFrom?: readonly string[] | undefined;
+    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,13 +4,13 @@ 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) {
     const firstPackage = blueprint.packages?.[0];
     const match = firstPackage?.name.match(/^@([^/]+)\//);
-    if (match) {
+    if (match?.[1]) {
         return match[1];
     }
     if (/^[a-z0-9][a-z0-9._-]*$/.test(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;
     }
@@ -314,9 +314,17 @@ async function packageManifestsForTaskGraph(options) {
     for (const packageDefinition of options.blueprint.packages ?? []) {
         const manifestOverride = options.manifestOverrides?.get(packageDefinition.path);
         const manifestFromOperations = generatedPackageManifestFromOperations(options.operations, packageDefinition.path);
-        manifests.push(manifestOverride ??
-            manifestFromOperations ??
-            (await readJson(path.join(options.root, packageDefinition.path, "package.json"))));
+        if (manifestOverride !== undefined) {
+            manifests.push(manifestOverride);
+            continue;
+        }
+        if (manifestFromOperations !== undefined) {
+            manifests.push(manifestFromOperations);
+            continue;
+        }
+        const manifest = await readJson(path.join(options.root, packageDefinition.path, "package.json"));
+        assertObjectManifest(manifest, packageDefinition.path);
+        manifests.push(manifest);
     }
     return manifests;
 }
@@ -348,7 +356,7 @@ function assertObjectManifest(input, packagePath) {
     }
 }
 function recordSortedByKey(record) {
-    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+    return Object.fromEntries(Object.entries(record).toSorted(([left], [right]) => left.localeCompare(right)));
 }
 async function consumerManifestUpdatesForPackageLinkIntents(options) {
     const updates = [];
@@ -425,16 +433,21 @@ function rootPackageJsonWithPackageTaskFilters(input, blueprint, packageManifest
     assertRootPackageJson(input);
     const workspacePackageGlobs = workspacePackageGlobsFromBlueprint(blueprint);
     const taskNames = turboTaskNamesForPackageManifests(packageManifests);
+    const checkScript = input.scripts.check;
+    const fixScript = input.scripts.fix;
+    if (checkScript === undefined || fixScript === undefined) {
+        throw new Error("Cannot update root Package Addition scripts: check and fix scripts are required");
+    }
     return {
         ...input,
         scripts: {
             ...input.scripts,
             check: rootScriptWithTurboPackageTasks({
-                script: input.scripts.check,
+                script: checkScript,
                 taskNames,
                 workspacePackageGlobs,
             }),
-            fix: rootScriptWithTurboPackageTask(input.scripts.fix, "fix", workspacePackageGlobs),
+            fix: rootScriptWithTurboPackageTask(fixScript, "fix", workspacePackageGlobs),
         },
     };
 }
@@ -483,6 +496,7 @@ function rootPackageJsonWithSharedOxcRuntimeDependencies(input, requiresSharedOx
             ...input.devDependencies,
             oxfmt: input.devDependencies?.oxfmt ?? "catalog:",
             oxlint: input.devDependencies?.oxlint ?? "catalog:",
+            "oxlint-tsgolint": input.devDependencies?.["oxlint-tsgolint"] ?? "catalog:",
         },
     };
 }
@@ -491,7 +505,7 @@ function catalogDependenciesWithSharedOxcRuntimeDependencies(catalogDependencies
     if (!requiresSharedOxcConfiguration) {
         return dependencies;
     }
-    for (const dependency of ["oxfmt", "oxlint"]) {
+    for (const dependency of ["oxfmt", "oxlint", "oxlint-tsgolint"]) {
         if (!dependencies.includes(dependency)) {
             dependencies.push(dependency);
         }
@@ -622,18 +636,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,9 +10,11 @@ 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
+  oxlint-tsgolint: ^0.24.0
   pinia: ^3.0.4
   tailwindcss: ^4.3.2
   tsc-alias: ^1.8.17
@@ -24,6 +26,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-projection.d.ts

@@ -20,7 +20,7 @@ export type PresetPackageAdditionPlan = {
     readonly packageRole: PackageRole;
     readonly packageSourcePreset: PackageSourcePreset;
     readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string>;
+    readonly sourceRoots?: Record<string, string> | undefined;
     readonly operations: readonly RenderOperation[];
     readonly textFiles?: readonly {
         readonly path: string;
@@ -32,7 +32,7 @@ export type PresetPackageAdditionCapability = {
 };
 export type PresetProjectionPlan = {
     readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string>;
+    readonly sourceRoots?: Record<string, string> | undefined;
     readonly operations: readonly RenderOperation[];
     readonly checkPlan: CheckPlan;
     readonly fixPlan: FixPlan;
@@ -48,7 +48,7 @@ export type PresetProjectionPlan = {
 };
 export type PresetBlueprintOptions = {
     readonly targetDir: string;
-    readonly scope?: string;
+    readonly scope?: string | undefined;
 };
 export type RenderPresetProjectionOptions = {
     readonly targetDir: string;

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

@@ -1,3 +1,4 @@
+import {} from "./module-graph.js";
 import { planNextStepInstructions, } from "./next-step-instructions.js";
 export function planNextStepInstructionsForProjection(options) {
     return planNextStepInstructions({

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}`,
     }));
 }
@@ -799,6 +797,64 @@ function supportedProjectionDeclarationIssues(presets) {
         ]
         : []);
 }
+function normalizePresetSourceManifestOutput(manifest) {
+    return {
+        schemaVersion: manifest.schemaVersion,
+        name: manifest.name,
+        sharedResources: manifest.sharedResources.map((resource) => ({
+            ...resource,
+        })),
+        ...(manifest.fixtureMatrix
+            ? {
+                fixtureMatrix: {
+                    initSupport: manifest.fixtureMatrix.initSupport.map((support) => ({
+                        ...support,
+                    })),
+                    packageAdditionSupport: manifest.fixtureMatrix.packageAdditionSupport.map((support) => ({
+                        ...support,
+                    })),
+                    supportedCombinations: manifest.fixtureMatrix.supportedCombinations.map((combination) => ({
+                        basePreset: combination.basePreset,
+                        addedPreset: combination.addedPreset,
+                        linkFrom: [...combination.linkFrom],
+                    })),
+                    semanticSkips: manifest.fixtureMatrix.semanticSkips.map((skip) => ({
+                        ...skip,
+                    })),
+                    checkRequirements: [...manifest.fixtureMatrix.checkRequirements],
+                    environmentPreparation: [
+                        ...manifest.fixtureMatrix.environmentPreparation,
+                    ],
+                },
+            }
+            : {}),
+        presets: manifest.presets.map((preset) => ({
+            name: preset.name,
+            title: preset.title,
+            description: preset.description,
+            generation: preset.generation,
+            packageAdditionSupport: preset.packageAdditionSupport,
+            supportedPackageManagers: [...preset.supportedPackageManagers],
+            supportedProjectKinds: [...preset.supportedProjectKinds],
+            features: [...preset.features],
+            dependencyCatalog: [...preset.dependencyCatalog],
+            ...(preset.projection
+                ? {
+                    projection: normalizePresetProjectionDeclaration(preset.projection),
+                }
+                : {}),
+            ...(preset.source
+                ? {
+                    source: {
+                        roots: [...preset.source.roots],
+                        files: [...preset.source.files],
+                        sharedResources: [...preset.source.sharedResources],
+                    },
+                }
+                : {}),
+        })),
+    };
+}
 export function validatePresetSourceManifest(input, options = {}) {
     const inlineDependencyIssues = inlineDependencyCatalogSpecifierIssues(input);
     if (inlineDependencyIssues.length > 0) {
@@ -825,50 +881,7 @@ export function validatePresetSourceManifest(input, options = {}) {
     }
     return {
         ok: true,
-        value: {
-            ...result.output,
-            sharedResources: result.output.sharedResources.map((resource) => ({
-                ...resource,
-            })),
-            fixtureMatrix: result.output.fixtureMatrix
-                ? {
-                    initSupport: result.output.fixtureMatrix.initSupport.map((support) => ({ ...support })),
-                    packageAdditionSupport: result.output.fixtureMatrix.packageAdditionSupport.map((support) => ({ ...support })),
-                    supportedCombinations: result.output.fixtureMatrix.supportedCombinations.map((combination) => ({
-                        ...combination,
-                        linkFrom: [...(combination.linkFrom ?? [])],
-                    })),
-                    semanticSkips: result.output.fixtureMatrix.semanticSkips.map((skip) => ({ ...skip })),
-                    checkRequirements: [
-                        ...result.output.fixtureMatrix.checkRequirements,
-                    ],
-                    environmentPreparation: [
-                        ...result.output.fixtureMatrix.environmentPreparation,
-                    ],
-                }
-                : undefined,
-            presets: parsedManifest.presets.map((preset) => ({
-                ...preset,
-                supportedPackageManagers: [
-                    ...preset.supportedPackageManagers,
-                ],
-                supportedProjectKinds: [
-                    ...preset.supportedProjectKinds,
-                ],
-                features: [...preset.features],
-                dependencyCatalog: [...(preset.dependencyCatalog ?? [])],
-                projection: preset.projection
-                    ? normalizePresetProjectionDeclaration(preset.projection)
-                    : undefined,
-                source: preset.source
-                    ? {
-                        roots: [...preset.source.roots],
-                        files: [...preset.source.files],
-                        sharedResources: [...preset.source.sharedResources],
-                    }
-                    : undefined,
-            })),
-        },
+        value: normalizePresetSourceManifestOutput(parsedManifest),
     };
 }
 export function validateBuiltInPresetSourceManifest(input, options = {}) {
@@ -910,7 +923,7 @@ export function manifestReferencedSourceFiles(manifest, sourceRoot) {
             addReference(file);
         }
     }
-    return [...files].sort();
+    return [...files].toSorted();
 }
 export function loadPresetSourceManifestFile(filePath) {
     const result = validatePresetSourceManifest(JSON.parse(readFileSync(filePath, "utf8")), { sourceRoot: path.dirname(filePath) });
@@ -921,20 +934,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}/project-github.d.ts

@@ -21,9 +21,9 @@ export type DependencyMaintenancePolicy = {
 };
 type ProjectCheckWorkflowOptions = {
     readonly checkPlan: CheckPlan;
-    readonly capability?: CiCapability;
-    readonly environmentPreparation?: Partial<CiEnvironmentPreparation>;
-    readonly taskLayer?: PnpmTaskLayer;
+    readonly capability?: CiCapability | undefined;
+    readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
+    readonly taskLayer?: PnpmTaskLayer | undefined;
 };
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;

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

@@ -1,3 +1,4 @@
+import {} from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",