@ykdz/template 0.0.5 → 0.0.6

package/dist/src/cli.js

@@ -2,11 +2,13 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { findBuiltInPresetProjection, projectPresetThroughRegistry, } from "../templates/registry.js";
 import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
 import { assembleGenerationContext, } from "./generation-context.js";
 import { addPackage } from "./package-addition.js";
 import { planNextStepInstructionsForProjection, } from "./preset-projection.js";
+import { findBuiltInPresetSourceManifestPreset, presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, } from "./preset-source.js";
+import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
+import { renderNewProject } from "./renderer.js";
 import { resolveToolchainVersions, } from "./toolchain-resolution.js";
 function usage() {
     return [
@@ -15,8 +17,10 @@ function usage() {
         "  template add package --preset <name> --name <name> [--path <package-path>] [--link-from <package-path>]...",
         "  template presets",
         "  template schema preset",
+        "  template schema preset-source",
         "  template schema blueprint",
         "  template preset validate <path>",
+        "  template preset-source validate <path>",
         "  template blueprint validate <path>",
         "",
         "Options:",
@@ -135,23 +139,10 @@ function formatList(values) {
 }
 function blueprintForInit(options) {
     const preset = supportedPreset(options.preset);
-    const projection = findBuiltInPresetProjection(preset.name);
-    if (projection) {
-        return projection.blueprint({
-            targetDir: options.dir,
-            scope: options.scope,
-        });
-    }
-    const blueprint = {
-        schemaVersion: 1,
-        preset: preset.name,
-        projectKind: preset.supportedProjectKinds[0],
-        features: [...preset.features],
-    };
-    if (preset.supportedPackageManagers[0]) {
-        blueprint.packageManager = preset.supportedPackageManagers[0];
-    }
-    return blueprint;
+    return blueprintForPresetSourcePreset(preset, {
+        targetDir: options.dir,
+        scope: options.scope,
+    });
 }
 function formatBlueprintSummary(targetDir, blueprint) {
     const lines = [
@@ -207,7 +198,8 @@ function toolchainResolutionSourceFromEnv() {
     return undefined;
 }
 async function generationContextForInit(options, blueprint) {
-    if (!findBuiltInPresetProjection(options.preset)) {
+    if (findBuiltInPresetSourceManifestPreset(options.preset)?.projection ===
+        undefined) {
         return undefined;
     }
     return assembleGenerationContext({
@@ -221,20 +213,28 @@ async function generationContextForInit(options, blueprint) {
     });
 }
 async function generateInitProject(options, generationContext) {
-    const projection = findBuiltInPresetProjection(options.preset);
-    if (projection) {
-        if (!generationContext) {
-            throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
-        }
-        const plan = projection.project(generationContext);
-        await projection.render({ targetDir: options.dir, plan });
-        return;
+    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    if (!preset?.projection) {
+        throw new Error(formatSupportedPresetError());
+    }
+    if (!generationContext) {
+        throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
     }
-    throw new Error(formatSupportedPresetError());
+    const plan = projectPresetSourcePreset({
+        preset,
+        context: generationContext,
+    });
+    await renderNewProject({
+        sourceRoot: plan.sourceRoot,
+        sourceRoots: plan.sourceRoots,
+        targetRoot: options.dir,
+        operations: [...plan.operations],
+    });
 }
 function printInitComplete(options, blueprint, generationContext) {
-    const projectionPlan = generationContext
-        ? projectPresetThroughRegistry(generationContext)
+    const preset = findBuiltInPresetSourceManifestPreset(blueprint.preset);
+    const projectionPlan = generationContext && preset?.projection
+        ? projectPresetSourcePreset({ preset, context: generationContext })
         : undefined;
     if (!projectionPlan) {
         throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
@@ -349,7 +349,11 @@ async function main(args) {
             printJson(blueprintJsonSchema);
             return;
         }
-        throw new Error("schema requires preset or blueprint");
+        if (schemaName === "preset-source") {
+            printJson(presetSourceManifestJsonSchema);
+            return;
+        }
+        throw new Error("schema requires preset, preset-source, or blueprint");
     }
     if (command === "preset" && args[1] === "validate") {
         const filePath = args[2];
@@ -363,6 +367,32 @@ async function main(args) {
         console.log(`Preset file is valid: ${result.value.name}`);
         return;
     }
+    if (command === "preset-source" && args[1] === "validate") {
+        const filePath = args[2];
+        if (!filePath) {
+            throw new Error("preset-source validate requires a path");
+        }
+        const declaration = await readJsonDeclaration(filePath);
+        const sourceName = typeof declaration === "object" &&
+            declaration !== null &&
+            !Array.isArray(declaration) &&
+            "name" in declaration &&
+            typeof declaration.name === "string"
+            ? declaration.name
+            : undefined;
+        const result = sourceName === "built-in"
+            ? validateBuiltInPresetSourceManifest(declaration, {
+                sourceRoot: path.dirname(filePath),
+            })
+            : validatePresetSourceManifest(declaration, {
+                sourceRoot: path.dirname(filePath),
+            });
+        if (!result.ok) {
+            throw new Error(`Preset Source Manifest is invalid:\n${formatValidationIssues(result.issues)}`);
+        }
+        console.log(`Preset Source Manifest is valid: ${result.value.name} (${result.value.presets.map((preset) => preset.name).join(", ")})`);
+        return;
+    }
     if (command === "blueprint" && args[1] === "validate") {
         const filePath = args[2];
         if (!filePath) {
@@ -380,8 +410,11 @@ async function main(args) {
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
             const generationContext = await generationContextForInit(options, blueprint);
+            const preset = findBuiltInPresetSourceManifestPreset(options.preset);
             const projectionPlan = generationContext
-                ? projectPresetThroughRegistry(generationContext)
+                ? preset?.projection
+                    ? projectPresetSourcePreset({ preset, context: generationContext })
+                    : undefined
                 : undefined;
             if (!projectionPlan) {
                 throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);

package/dist/src/declarations.js

@@ -1,6 +1,6 @@
 import * as v from "valibot";
-import { builtInPresetMetadata } from "../templates/registry.js";
-export const builtInPresets = builtInPresetMetadata;
+import { loadBuiltInPresetSourceManifest } from "./preset-source.js";
+export const builtInPresets = loadBuiltInPresetSourceManifest().presets;
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",

package/dist/src/generated-scenarios.d.ts

@@ -0,0 +1,62 @@
+import type { PresetSourceManifest } from "./preset-source.js";
+export type GeneratedScenarioSet = "init" | "package-addition-matrix";
+export type GeneratedScenario = {
+    readonly set: GeneratedScenarioSet;
+    readonly basePreset: string;
+    readonly addedPreset?: string;
+    readonly linkFrom?: readonly string[];
+    readonly id: string;
+    readonly label: string;
+};
+export type SkippedGeneratedScenario = {
+    readonly set: GeneratedScenarioSet;
+    readonly basePreset: string;
+    readonly addedPreset: string;
+    readonly id: string;
+    readonly label: string;
+    readonly reason: string;
+};
+export type GeneratedScenarioSelection = {
+    readonly runnable: readonly GeneratedScenario[];
+    readonly skipped: readonly SkippedGeneratedScenario[];
+};
+export type GeneratedScenarioCommandStep = {
+    readonly id: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly display: string;
+};
+export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
+    readonly env?: Record<string, string>;
+    readonly logPrefix?: string;
+}) => Promise<void>;
+export type GeneratedScenarioReporter = {
+    readonly info?: (message: string) => void;
+    readonly error?: (message: string) => void;
+};
+export type GeneratedScenarioRunnerOptions = {
+    readonly repoRoot: string;
+    readonly cliPath: string;
+    readonly runCommand?: GeneratedScenarioCommandRunner;
+    readonly reporter?: GeneratedScenarioReporter;
+    readonly deterministicToolchainEnv?: Record<string, string>;
+    readonly rootCheckLock?: ExclusiveLock;
+};
+export type ExclusiveLock = {
+    readonly run: <T>(callback: () => Promise<T>) => Promise<T>;
+};
+export declare function createExclusiveLock(): ExclusiveLock;
+export declare function generatedScenarioId(scenario: Pick<GeneratedScenario, "basePreset" | "addedPreset" | "linkFrom">): string;
+export declare function generatedScenarioLabel(scenario: Pick<GeneratedScenario, "basePreset" | "addedPreset" | "linkFrom">): string;
+export declare function selectGeneratedScenarios(manifest: PresetSourceManifest, set: GeneratedScenarioSet): GeneratedScenarioSelection;
+export declare function packageLeafNameForAddedPreset(manifest: PresetSourceManifest, presetName: string): string;
+export declare function defaultGeneratedScenarioCommandRunner(command: string, args: readonly string[], cwd: string, options?: {
+    readonly env?: Record<string, string>;
+    readonly logPrefix?: string;
+}): Promise<void>;
+export declare function generatedScenarioQualityGateSteps(manifest: PresetSourceManifest, scenario: GeneratedScenario, projectDir: string, addedPackagePath: string | undefined, options: GeneratedScenarioRunnerOptions): GeneratedScenarioCommandStep[];
+export declare function fixtureConcurrency(scenarioCount: number): number;
+export declare function errorForFailedGeneratedScenario(scenario: GeneratedScenario, error: unknown): Error;
+export declare function runGeneratedScenariosConcurrently(manifest: PresetSourceManifest, scenarios: readonly GeneratedScenario[], workspace: string, concurrency: number, options: GeneratedScenarioRunnerOptions): Promise<void>;
+export declare function runGeneratedScenarioSet(manifest: PresetSourceManifest, set: GeneratedScenarioSet, workspace: string, options: GeneratedScenarioRunnerOptions): Promise<GeneratedScenarioSelection>;

package/dist/src/generated-scenarios.js

@@ -0,0 +1,361 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { execa } from "execa";
+import { assembleGenerationContext } from "./generation-context.js";
+import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { planNextStepInstructions } from "./next-step-instructions.js";
+import { findPresetSourceManifestPreset } from "./preset-source.js";
+import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
+const defaultDeterministicToolchainEnv = {
+    TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
+};
+const defaultFixtureConcurrency = 2;
+export function createExclusiveLock() {
+    let tail = Promise.resolve();
+    return {
+        async run(callback) {
+            const previous = tail;
+            let release;
+            tail = new Promise((resolve) => {
+                release = resolve;
+            });
+            await previous;
+            try {
+                return await callback();
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}
+export function generatedScenarioId(scenario) {
+    if (!scenario.addedPreset) {
+        return scenario.basePreset;
+    }
+    if (scenario.linkFrom && scenario.linkFrom.length > 0) {
+        const linkFromId = scenario.linkFrom
+            .map((packagePath) => packagePath.replaceAll("/", "-"))
+            .join("-");
+        return `${scenario.basePreset}-add-${scenario.addedPreset}-link-from-${linkFromId}`;
+    }
+    return `${scenario.basePreset}-add-${scenario.addedPreset}`;
+}
+export function generatedScenarioLabel(scenario) {
+    if (!scenario.addedPreset) {
+        return scenario.basePreset;
+    }
+    if (scenario.linkFrom && scenario.linkFrom.length > 0) {
+        return `${scenario.basePreset} + ${scenario.addedPreset} linked from ${scenario.linkFrom.join(", ")}`;
+    }
+    return `${scenario.basePreset} + ${scenario.addedPreset}`;
+}
+function scenario(set, input) {
+    return {
+        set,
+        basePreset: input.basePreset,
+        addedPreset: input.addedPreset,
+        linkFrom: input.linkFrom ? [...input.linkFrom] : undefined,
+        id: generatedScenarioId(input),
+        label: generatedScenarioLabel(input),
+    };
+}
+export function selectGeneratedScenarios(manifest, set) {
+    const contract = manifest.fixtureMatrix;
+    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 }));
+    if (set === "init") {
+        return { runnable: initScenarios, skipped: [] };
+    }
+    const matrixScenarios = contract.supportedCombinations.map((combination) => scenario(set, {
+        basePreset: combination.basePreset,
+        addedPreset: combination.addedPreset,
+        linkFrom: combination.linkFrom,
+    }));
+    const skipped = contract.semanticSkips.map((skip) => ({
+        set,
+        basePreset: skip.basePreset,
+        addedPreset: skip.addedPreset,
+        id: generatedScenarioId(skip),
+        label: generatedScenarioLabel(skip),
+        reason: skip.reason,
+    }));
+    return {
+        runnable: matrixScenarios,
+        skipped,
+    };
+}
+export function packageLeafNameForAddedPreset(manifest, presetName) {
+    const support = manifest.fixtureMatrix?.packageAdditionSupport.find((entry) => entry.preset === presetName);
+    if (!support) {
+        throw new Error(`Missing fixture Package Addition leaf name for preset: ${presetName}`);
+    }
+    return support.packageLeafName;
+}
+export async function defaultGeneratedScenarioCommandRunner(command, args, cwd, options = {}) {
+    const prefix = options.logPrefix ? `[${options.logPrefix}] ` : "";
+    console.log(`${prefix}$ ${[command, ...args].join(" ")}`);
+    await execa(command, [...args], {
+        cwd,
+        env: options.env,
+        stdio: "inherit",
+    });
+}
+async function generateScenario(scenario, workspace, options) {
+    const projectDir = path.join(workspace, `fixture-${scenario.id}`);
+    await options.runCommand("pnpm", [
+        "exec",
+        "tsx",
+        options.cliPath,
+        "init",
+        projectDir,
+        "--preset",
+        scenario.basePreset,
+        "--yes",
+    ], options.repoRoot, {
+        env: options.deterministicToolchainEnv,
+        logPrefix: scenario.label,
+    });
+    return projectDir;
+}
+async function applyPackageAddition(manifest, scenario, projectDir, options) {
+    if (!scenario.addedPreset) {
+        return undefined;
+    }
+    const packageLeafName = packageLeafNameForAddedPreset(manifest, scenario.addedPreset);
+    const beforeConsumerSources = await linkedConsumerSourceSnapshots(projectDir, scenario.linkFrom ?? []);
+    await options.runCommand("pnpm", [
+        "exec",
+        "tsx",
+        options.cliPath,
+        "add",
+        "package",
+        "--preset",
+        scenario.addedPreset,
+        "--name",
+        packageLeafName,
+        ...linkFromArgs(scenario.linkFrom ?? []),
+    ], projectDir, { logPrefix: scenario.label });
+    await assertLinkedConsumerSourcesUnchanged(projectDir, beforeConsumerSources);
+    return readAddedPackagePath(projectDir, packageLeafName);
+}
+function linkFromArgs(packagePaths) {
+    return packagePaths.flatMap((packagePath) => ["--link-from", packagePath]);
+}
+async function linkedConsumerSourceSnapshots(projectDir, packagePaths) {
+    const snapshots = new Map();
+    for (const packagePath of packagePaths) {
+        snapshots.set(packagePath, await sourceFileSnapshot(path.join(projectDir, packagePath, "src")));
+    }
+    return snapshots;
+}
+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))) {
+        const entryPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            Object.assign(snapshot, await sourceFileSnapshot(sourceDir, entryPath));
+            continue;
+        }
+        if (entry.isFile()) {
+            snapshot[path.relative(sourceDir, entryPath)] = await readFile(entryPath, "utf8");
+        }
+    }
+    return snapshot;
+}
+async function assertLinkedConsumerSourcesUnchanged(projectDir, beforeSnapshots) {
+    for (const [packagePath, beforeSnapshot] of beforeSnapshots) {
+        const afterSnapshot = await sourceFileSnapshot(path.join(projectDir, packagePath, "src"));
+        if (JSON.stringify(afterSnapshot) !== JSON.stringify(beforeSnapshot)) {
+            throw new Error(`Package Link Intent fixture modified consumer source files for ${packagePath}`);
+        }
+    }
+}
+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);
+    if (!packageDefinition) {
+        throw new Error(`Package Addition fixture did not record package leaf ${packageLeafName}`);
+    }
+    return packageDefinition.path;
+}
+function projectionPlanForPreset(presetName, projectDir, manifest, options, packageScope) {
+    const preset = findPresetSourceManifestPreset(manifest, presetName);
+    if (!preset?.projection) {
+        throw new Error(`Missing Preset Projection for fixture preset ${presetName}`);
+    }
+    const blueprint = blueprintForPresetSourcePreset(preset, {
+        targetDir: projectDir,
+        scope: packageScope,
+    });
+    return projectPresetSourcePreset({
+        preset,
+        context: assembleGenerationContext({
+            targetDir: projectDir,
+            blueprint,
+            toolchain: {
+                nodeLtsMajor: { kind: "NodeLtsMajor", value: "24" },
+                packageManagerPin: { kind: "PackageManagerPin", value: "pnpm@10.0.0" },
+                source: "bundled-fallback",
+                diagnostics: [],
+            },
+        }),
+    });
+}
+function machineVerifiableNextStepsForPreset(presetName, projectDir, manifest, options) {
+    const projectionPlan = projectionPlanForPreset(presetName, projectDir, manifest, options);
+    const plan = planNextStepInstructions({
+        targetDir: projectDir,
+        projectionPlan,
+    });
+    return plan.steps
+        .filter((step) => step.machineVerifiable && step.kind === "command")
+        .map((step) => ({
+        id: step.id,
+        command: step.command,
+        args: step.args,
+        cwd: step.cwd,
+        display: step.display,
+    }));
+}
+function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, options) {
+    if (!scenario.addedPreset || !addedPackagePath) {
+        return [];
+    }
+    return projectionPlanForPreset(scenario.addedPreset, projectDir, manifest, options, path.basename(projectDir)).checkPlan.environmentNeeds.map((need) => {
+        if (need.owner.kind !== "package-boundary") {
+            return need;
+        }
+        return {
+            ...need,
+            owner: { kind: "package-boundary", path: addedPackagePath },
+        };
+    });
+}
+function environmentNeedStep(need, projectDir) {
+    const display = renderPlaywrightBrowserInstallCommand(need);
+    const [command, ...args] = display.split(" ");
+    return {
+        id: `install-${need.owner.path}-playwright-browsers`,
+        command,
+        args,
+        cwd: projectDir,
+        display,
+    };
+}
+export function generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    const steps = machineVerifiableNextStepsForPreset(scenario.basePreset, projectDir, manifest, normalizedOptions);
+    const addedEnvironmentSteps = addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, normalizedOptions).map((need) => environmentNeedStep(need, projectDir));
+    const existingDisplays = new Set(steps.map((step) => step.display));
+    const extraEnvironmentSteps = addedEnvironmentSteps.filter((step) => !existingDisplays.has(step.display));
+    if (extraEnvironmentSteps.length === 0) {
+        return steps;
+    }
+    const rootCheckIndex = steps.findIndex((step) => step.id === "run-root-check");
+    if (rootCheckIndex === -1) {
+        return [...steps, ...extraEnvironmentSteps];
+    }
+    return [
+        ...steps.slice(0, rootCheckIndex),
+        ...extraEnvironmentSteps,
+        ...steps.slice(rootCheckIndex),
+    ];
+}
+async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options) {
+    const steps = generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options);
+    const requiresSerializedPlaywrightRootCheck = steps.some((step) => step.id.endsWith("-playwright-browsers"));
+    for (const step of steps) {
+        const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
+        const runStep = async () => {
+            await options.runCommand(step.command, [...step.args], step.cwd, {
+                env,
+                logPrefix: scenario.label,
+            });
+        };
+        if (step.id === "run-root-check" && requiresSerializedPlaywrightRootCheck) {
+            await options.rootCheckLock.run(runStep);
+            continue;
+        }
+        await runStep();
+    }
+}
+async function checkGeneratedScenario(manifest, scenario, workspace, options) {
+    options.reporter.info?.(`\n== ${scenario.label} ==`);
+    const projectDir = await generateScenario(scenario, workspace, options);
+    const addedPackagePath = await applyPackageAddition(manifest, scenario, projectDir, options);
+    await runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options);
+}
+export function fixtureConcurrency(scenarioCount) {
+    const rawValue = process.env.TEMPLATE_FIXTURE_CONCURRENCY;
+    if (rawValue === undefined || rawValue === "") {
+        return Math.min(defaultFixtureConcurrency, scenarioCount);
+    }
+    const value = Number(rawValue);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error("TEMPLATE_FIXTURE_CONCURRENCY must be a positive integer");
+    }
+    return Math.min(value, scenarioCount);
+}
+export function errorForFailedGeneratedScenario(scenario, error) {
+    if (error instanceof Error) {
+        return new Error(`Fixture scenario failed: ${scenario.label}`, {
+            cause: error,
+        });
+    }
+    return new Error(`Fixture scenario failed: ${scenario.label}: ${String(error)}`);
+}
+function normalizeRunnerOptions(options) {
+    return {
+        repoRoot: options.repoRoot,
+        cliPath: options.cliPath,
+        runCommand: options.runCommand ?? defaultGeneratedScenarioCommandRunner,
+        reporter: options.reporter ?? {
+            info: console.log,
+            error: console.error,
+        },
+        deterministicToolchainEnv: options.deterministicToolchainEnv ?? defaultDeterministicToolchainEnv,
+        rootCheckLock: options.rootCheckLock ?? createExclusiveLock(),
+    };
+}
+export async function runGeneratedScenariosConcurrently(manifest, scenarios, workspace, concurrency, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    let nextScenarioIndex = 0;
+    let firstFailure;
+    async function worker() {
+        while (firstFailure === undefined) {
+            const scenario = scenarios[nextScenarioIndex];
+            nextScenarioIndex += 1;
+            if (!scenario) {
+                return;
+            }
+            try {
+                await checkGeneratedScenario(manifest, scenario, workspace, normalizedOptions);
+            }
+            catch (error) {
+                firstFailure ??= errorForFailedGeneratedScenario(scenario, error);
+                return;
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: concurrency }, async () => {
+        await worker();
+    }));
+    if (firstFailure) {
+        throw firstFailure;
+    }
+}
+export async function runGeneratedScenarioSet(manifest, set, workspace, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    const selection = selectGeneratedScenarios(manifest, set);
+    const concurrency = fixtureConcurrency(selection.runnable.length);
+    for (const skippedScenario of selection.skipped) {
+        normalizedOptions.reporter.info?.(`-- Skipping ${skippedScenario.label}: ${skippedScenario.reason}`);
+    }
+    normalizedOptions.reporter.info?.(`Checking ${selection.runnable.length} fixture scenarios with concurrency ${concurrency}.`);
+    await runGeneratedScenariosConcurrently(manifest, selection.runnable, workspace, concurrency, normalizedOptions);
+    return selection;
+}

package/dist/src/package-addition.js

@@ -1,10 +1,11 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { builtInPresetProjections, findBuiltInPresetProjection, } from "../templates/registry.js";
 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 { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, } from "./projection-capabilities.js";
 import { renderProject } from "./renderer.js";
 function projectNameFromBlueprint(blueprint, fallbackProjectName) {
     const firstPackage = blueprint.packages?.[0];
@@ -74,16 +75,10 @@ function validateExplicitPackagePath(packagePath) {
     }
     return packagePath;
 }
-function defaultPackagePathForPreset(preset, packageLeafName) {
-    return preset === "ts-lib"
-        ? `packages/${packageLeafName}`
-        : `apps/${packageLeafName}`;
-}
 function supportedPackageAdditionPresetNames() {
-    return builtInPresetProjections
-        .filter((projection) => projection.metadata.packageAdditionSupport ===
-        PackageAdditionSupport.Supported)
-        .map((projection) => projection.metadata.name);
+    return loadBuiltInPresetSourceManifest()
+        .presets.filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported)
+        .map((preset) => preset.name);
 }
 function formatUnsupportedPackageAdditionPresetError(preset) {
     return [
@@ -627,28 +622,26 @@ export async function addPackage(options) {
     const repositoryMetadata = await readGeneratedRepositoryPackageMetadata(root);
     const projectName = projectNameFromBlueprint(blueprint, repositoryMetadata.projectName);
     const packageName = `@${projectName}/${options.name}`;
-    const packagePath = options.path
-        ? validateExplicitPackagePath(options.path)
-        : defaultPackagePathForPreset(options.preset, options.name);
-    const projection = findBuiltInPresetProjection(options.preset);
-    if (!projection) {
+    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    if (!preset) {
         throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
     }
-    if (projection.metadata.packageAdditionSupport !==
-        PackageAdditionSupport.Supported) {
+    if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
         throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset));
     }
-    const packageAddition = projection.capabilities?.packageAddition;
-    if (!packageAddition) {
-        throw new Error(`Preset ${options.preset} declares Package Addition support but has no Package Addition implementation`);
-    }
-    const additionPlan = await packageAddition.planPackageAddition({
-        root,
-        blueprint,
-        packageLeafName: options.name,
-        packageName,
-        packagePath,
-        nodeVersion: repositoryMetadata.nodeVersion,
+    const packagePath = options.path
+        ? validateExplicitPackagePath(options.path)
+        : defaultPackagePathForPresetSourcePackageAddition(preset, options.name);
+    const additionPlan = await planPresetSourcePackageAddition({
+        preset,
+        addition: {
+            root,
+            blueprint,
+            packageLeafName: options.name,
+            packageName,
+            packagePath,
+            nodeVersion: repositoryMetadata.nodeVersion,
+        },
     });
     const requiresSharedOxcConfiguration = additionPlan.sourceRoots?.sharedOxc !== undefined;
     assertNoPackageConflict(blueprint, packageName, additionPlan.packagePath);
@@ -663,7 +656,7 @@ export async function addPackage(options) {
         packageLinkIntents,
     });
     await assertMissingPackagePath(additionPlan.packagePath, path.join(root, additionPlan.packagePath));
-    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, additionPlan.workspacePackageGlob, packageAdditionCatalogDependencies(additionPlan.operations), requiresSharedOxcConfiguration, additionPlan.operations);
+    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, additionPlan.workspaceMembershipGlob ?? additionPlan.workspacePackageGlob, packageAdditionCatalogDependencies(additionPlan.operations), requiresSharedOxcConfiguration, additionPlan.operations);
     await mkdir(path.join(root, additionPlan.packagePath), { recursive: true });
     await ensureRootOxcConfiguration({
         root,