@ykdz/template 0.0.18 → 0.0.20

package/node_modules/@ykdz/template-core/dist/generated-scenarios.js

@@ -1,10 +1,12 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
+import { PackageAdditionSupport } from "@ykdz/template-shared";
 import { execa } from "execa";
 import * as v from "valibot";
 import { assembleGenerationContext } from "./generation-context.js";
 import { playwrightBrowserAssetsEnvironmentNeed, } from "./module-graph.js";
 import { planNextStepInstructions } from "./next-step-instructions.js";
+import { canPlanPackageLinkIntent, } from "./package-linking.js";
 import { findPresetSourceManifestPreset } from "./preset-source.js";
 import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
 const defaultDeterministicToolchainEnv = {
@@ -83,40 +85,105 @@ function createGeneratedScenario(set, 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) => createGeneratedScenario(set, { basePreset: support.preset }));
+    const supportedInitPresets = manifest.presets.filter((preset) => preset.generation === "supported");
+    const initScenarios = supportedInitPresets.map((preset) => createGeneratedScenario("init", { basePreset: preset.name }));
     if (set === "init") {
         return { runnable: initScenarios, skipped: [] };
     }
-    const matrixScenarios = contract.supportedCombinations.map((combination) => createGeneratedScenario(set, {
-        basePreset: combination.basePreset,
-        addedPreset: combination.addedPreset,
-        ...(combination.linkFrom === undefined
-            ? {}
-            : { 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,
-    }));
+    const addablePresets = manifest.presets.filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported);
+    const focusedScenarios = selectFocusedGeneratedScenarios(manifest, addablePresets);
+    if (set === "focused") {
+        return {
+            runnable: focusedScenarios,
+            skipped: [],
+        };
+    }
+    const matrixScenarios = supportedInitPresets.flatMap((basePreset) => addablePresets.map((addedPreset) => createGeneratedScenario("package-addition-matrix", {
+        basePreset: basePreset.name,
+        addedPreset: addedPreset.name,
+    })));
     return {
-        runnable: matrixScenarios,
-        skipped,
+        runnable: [...matrixScenarios, ...focusedScenarios],
+        skipped: [],
     };
 }
+function selectFocusedGeneratedScenarios(manifest, addablePresets) {
+    return manifest.presets
+        .filter((preset) => preset.generation === "supported")
+        .flatMap((basePreset) => addablePresets.flatMap((addedPreset) => {
+        const consumerPackagePath = focusedPackageLinkConsumerPath(basePreset, addedPreset);
+        return consumerPackagePath === undefined
+            ? []
+            : [
+                createGeneratedScenario("focused", {
+                    basePreset: basePreset.name,
+                    addedPreset: addedPreset.name,
+                    linkFrom: [consumerPackagePath],
+                }),
+            ];
+    }));
+}
+function focusedPackageLinkConsumerPath(basePreset, addedPreset) {
+    const providers = packageLinkProviderDefinitions(addedPreset);
+    return packageLinkConsumerDefinitions(basePreset).find((consumer) => providers.some((provider) => canPlanPackageLinkIntent({ consumer, provider })))?.path;
+}
+function packageLinkProviderDefinitions(preset) {
+    return (preset.projection?.capabilities.flatMap((capability) => {
+        if (capability.kind !== "workspace-library-package") {
+            return [];
+        }
+        const packageLeafName = `fixture-${preset.name}`;
+        return [
+            {
+                name: `@fixture/${packageLeafName}`,
+                path: `${packageCollection(capability.workspacePackageGlob)}/${packageLeafName}`,
+                role: capability.packageRole,
+                sourcePreset: capability.packageSourcePreset,
+            },
+        ];
+    }) ?? []);
+}
+function packageLinkConsumerDefinitions(preset) {
+    return (preset.projection?.capabilities.flatMap((capability) => {
+        if (capability.kind !== "workspace-node-packages") {
+            return [];
+        }
+        return capability.packages
+            .filter((nodePackage) => nodePackage.sourceFiles.some((sourceFile) => hasSourceDirectoryPath(sourceFile)))
+            .map((nodePackage) => ({
+            name: `@fixture/${packageLeaf(nodePackage.path)}`,
+            path: nodePackage.path,
+            role: "runtime-service",
+            sourcePreset: nodePackage.kind,
+        }));
+    }) ?? []);
+}
+function packageCollection(workspacePackageGlob) {
+    const [collection, wildcard] = workspacePackageGlob.split("/");
+    if (!collection || wildcard !== "*") {
+        throw new Error(`Unsupported workspace package glob: ${workspacePackageGlob}`);
+    }
+    return collection;
+}
+function packageLeaf(packagePath) {
+    return packagePath.split("/").at(-1) ?? packagePath;
+}
+function hasSourceDirectoryPath(sourceFile) {
+    return sourceFile.startsWith("src/") || sourceFile.includes("/src/");
+}
 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}`);
+    const preset = manifest.presets.find((entry) => entry.name === presetName);
+    if (!preset) {
+        throw new Error(`Unknown fixture Package Addition preset: ${presetName}`);
+    }
+    if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
+        throw new Error(`Preset ${presetName} cannot be used for fixture Package Addition`);
     }
-    return support.packageLeafName;
+    const packageLeafName = `fixture-${presetName}`;
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(packageLeafName)) {
+        throw new Error(`Fixture Package Addition leaf name for preset ${presetName} must be a lowercase package leaf name using letters, numbers, and hyphens`);
+    }
+    return packageLeafName;
 }
 export async function defaultGeneratedScenarioCommandRunner(command, args, cwd, options = {}) {
     const prefix = options.logPrefix ? `[${options.logPrefix}] ` : "";
@@ -317,6 +384,10 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
     const steps = generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options);
     const requiresSerializedPlaywrightRootCheck = generatedScenarioRequiresSerializedRootCheck(steps);
     for (const step of steps) {
+        if (step.id === "install-dependencies") {
+            await runGeneratedScenarioInstallStep(step, scenario, options);
+            continue;
+        }
         const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
         const runStep = async () => {
             await options.runCommand(step.command, [...step.args], step.cwd, {
@@ -331,6 +402,13 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
         await runStep();
     }
 }
+async function runGeneratedScenarioInstallStep(step, scenario, options) {
+    await options.runCommand(step.command, ["install", "--lockfile-only", "--prefer-offline", "--no-frozen-lockfile"], step.cwd, { logPrefix: scenario.label });
+    await options.runCommand(step.command, ["fetch"], step.cwd, {
+        logPrefix: scenario.label,
+    });
+    await options.runCommand(step.command, ["install", "--offline", "--frozen-lockfile"], step.cwd, { logPrefix: scenario.label });
+}
 async function checkGeneratedScenario(manifest, scenario, workspace, options) {
     options.reporter.info?.(`\n== ${scenario.label} ==`);
     const projectDir = await generateScenario(scenario, workspace, options);

package/node_modules/@ykdz/template-core/dist/next-step-instructions.d.ts

@@ -1,5 +1,6 @@
 import type { CheckEnvironmentNeed } from "./module-graph.js";
 import type { PresetProjectionPlan } from "./preset-projection.js";
+import type { RenderOperation } from "./renderer.js";
 export type NextStepInstruction = {
     readonly id: string;
     readonly label: string;
@@ -19,4 +20,11 @@ export type PlanNextStepInstructionsOptions = {
     readonly targetDir: string;
     readonly projectionPlan: PresetProjectionPlan;
 };
+export type FollowUpDocumentPlan = {
+    readonly enabled: boolean;
+    readonly path?: "TODO.md";
+};
 export declare function planNextStepInstructions(options: PlanNextStepInstructionsOptions): NextStepInstructionPlan;
+export declare function formatNextStepInstructionsForCli(plan: NextStepInstructionPlan): string;
+export declare function formatGeneratedFollowUpDocument(plan: NextStepInstructionPlan): string;
+export declare function generatedFollowUpDocumentOperation(plan: NextStepInstructionPlan): RenderOperation;

package/node_modules/@ykdz/template-core/dist/next-step-instructions.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 function rootCheckInstruction() {
     return {
         id: "run-root-check",
@@ -114,3 +115,67 @@ export function planNextStepInstructions(options) {
         steps: Object.freeze([navigationStep, ...commandSteps].map((step) => Object.freeze(step))),
     });
 }
+export function formatNextStepInstructionsForCli(plan) {
+    return [
+        "Next Step Instructions:",
+        "",
+        ...plan.steps.flatMap((step, index) => [
+            `  ${index + 1}. ${step.label}`,
+            `     ${step.display}`,
+        ]),
+    ].join("\n");
+}
+function isOptionalGitInstruction(step) {
+    return step.id.startsWith("optional-git-");
+}
+function relativeCwd(plan, step) {
+    const targetDir = path.resolve(plan.targetDir);
+    const cwd = path.resolve(step.cwd);
+    if (cwd === targetDir) {
+        return undefined;
+    }
+    const relative = path.relative(targetDir, cwd);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        return cwd;
+    }
+    return relative;
+}
+function taskTitle(step) {
+    const title = step.label.replace(/^Optional:\s*/, "");
+    return `${title.slice(0, 1).toUpperCase()}${title.slice(1)}`;
+}
+function formatTodoTask(plan, step) {
+    const taskLines = [`- [ ] ${taskTitle(step)}`];
+    const cwd = relativeCwd(plan, step);
+    if (cwd !== undefined) {
+        taskLines.push(`  From \`${cwd}\`:`);
+    }
+    taskLines.push(`  \`${step.display}\``);
+    return taskLines;
+}
+export function formatGeneratedFollowUpDocument(plan) {
+    const projectLocalSteps = plan.steps.filter((step) => step.kind === "command");
+    const nextSteps = projectLocalSteps.filter((step) => !isOptionalGitInstruction(step));
+    const optionalGitSteps = projectLocalSteps.filter(isOptionalGitInstruction);
+    return [
+        "# TODO",
+        "",
+        "Generated follow-up tasks for this repository.",
+        "",
+        "### Next Steps",
+        ...nextSteps.flatMap((step) => formatTodoTask(plan, step)),
+        "",
+        "### Optional Git Setup",
+        ...optionalGitSteps.flatMap((step) => formatTodoTask(plan, step)),
+        "",
+        "### Done ✓",
+        "",
+    ].join("\n");
+}
+export function generatedFollowUpDocumentOperation(plan) {
+    return {
+        kind: "writeText",
+        to: "TODO.md",
+        text: formatGeneratedFollowUpDocument(plan),
+    };
+}

package/node_modules/@ykdz/template-core/dist/package-addition.js

@@ -4,7 +4,7 @@ import { validateProjectBlueprint, } from "@ykdz/template-shared";
 import { PackageAdditionSupport, } from "@ykdz/template-shared";
 import { collectGeneratedManifestCatalogReferences, pnpmWorkspaceYamlWithCatalogDependencies, } from "./dependency-catalog.js";
 import { renderTurboRunCommand } from "./module-graph.js";
-import { assertTypeScriptPackageBoundaryForLinkIntent, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
+import { assertTypeScriptPackageBoundaryForLinkIntent, packageTurboConfig, planPackageLinks, } from "./package-linking.js";
 import { findPresetSourceManifestPreset, } from "./preset-source.js";
 import { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, } from "./projection-capabilities.js";
 import { renderProject } from "./renderer.js";
@@ -386,8 +386,7 @@ function rootScriptWithTurboPackageTasks(options) {
     const rootCommands = options.script
         .split(" && ")
         .filter((command) => !command.startsWith("turbo run "));
-    const turboArgs = options.concurrency === undefined ? [] : ["--concurrency=1"];
-    const turboCommand = renderTurboRunCommand(options.taskNames, turboArgs);
+    const turboCommand = renderTurboRunCommand(options.taskNames);
     return [...rootCommands, turboCommand].join(" && ");
 }
 function rootPackageJsonWithPackageTaskFilters(input, blueprint) {
@@ -413,7 +412,6 @@ function rootPackageJsonWithPackageTaskFilters(input, blueprint) {
                     "test:e2e:run",
                     "check:run",
                 ],
-                concurrency: 1,
             }),
             fix: rootScriptWithTurboPackageTasks({
                 script: fixScript,
@@ -444,11 +442,9 @@ function packageManifestsNeedDependencyBuilds(manifests) {
     return manifests.some((manifest) => Object.entries(manifest.dependencies ?? {}).some(([dependencyName, specifier]) => specifier === "workspace:*" && compiledPackageNames.has(dependencyName)));
 }
 function turboConfigForPackageManifests(manifests) {
-    return {
-        tasks: packageTurboTasks({
-            dependencyBuildsRequired: packageManifestsNeedDependencyBuilds(manifests),
-        }),
-    };
+    return packageTurboConfig({
+        dependencyBuildsRequired: packageManifestsNeedDependencyBuilds(manifests),
+    });
 }
 function rootPackageJsonWithSharedOxcRuntimeDependencies(input, requiresSharedOxcConfiguration) {
     if (!requiresSharedOxcConfiguration) {

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

@@ -32,12 +32,33 @@ export type PackageManifestExposureFields = {
     readonly types?: string;
 };
 export type PackageLinkBoundaryDirection = "consumer" | "provider";
+export type PackageLinkIntentCompatibility = {
+    readonly consumer: PackageDefinition;
+    readonly provider: PackageDefinition;
+};
 export type TurboTaskDefinition = {
     readonly dependsOn?: readonly string[];
     readonly outputs?: readonly string[];
     readonly cache?: boolean;
 };
 export type TurboTaskGraph = Readonly<Record<string, TurboTaskDefinition>>;
+export type TurboBoundaryRule = {
+    readonly dependencies?: {
+        readonly allow?: readonly string[];
+        readonly deny?: readonly string[];
+    };
+    readonly dependents?: {
+        readonly allow?: readonly string[];
+        readonly deny?: readonly string[];
+    };
+};
+export type TurboBoundaries = {
+    readonly tags: Readonly<Record<string, TurboBoundaryRule>>;
+};
+export type TurboConfig = {
+    readonly tasks: TurboTaskGraph;
+    readonly boundaries: TurboBoundaries;
+};
 export type PackageTurboTaskOptions = {
     readonly dependencyBuildsRequired: boolean;
 };
@@ -46,6 +67,9 @@ export declare function assertTypeScriptPackageBoundaryForLinkIntent(definition:
     readonly role: PackageRole;
     readonly sourcePreset: PackageSourcePreset;
 };
+export declare function canPlanPackageLinkIntent({ consumer, provider, }: PackageLinkIntentCompatibility): boolean;
 export declare function planPackageLinks(definitions: readonly PackageDefinition[], intents?: readonly PackageLinkIntent[]): PackageLinkPlan;
 export declare function packageTurboTasks({ dependencyBuildsRequired, }: PackageTurboTaskOptions): TurboTaskGraph;
+export declare function generatedRepositoryTurboBoundaries(): TurboBoundaries;
+export declare function packageTurboConfig(options: PackageTurboTaskOptions): TurboConfig;
 export declare function packageManifestExposureFields(exposure: PackageExposure): PackageManifestExposureFields;

package/node_modules/@ykdz/template-core/dist/package-linking.js

@@ -28,6 +28,17 @@ export function assertTypeScriptPackageBoundaryForLinkIntent(definition, directi
     const relationship = direction === "consumer" ? "from native package" : "to native package";
     throw new Error(`Package Link Intent ${relationship} ${definition.path} is unsupported in V1 TypeScript-only Project Linking`);
 }
+export function canPlanPackageLinkIntent({ consumer, provider, }) {
+    try {
+        assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
+        assertTypeScriptPackageBoundaryForLinkIntent(provider, "provider");
+        derivePackageExposure(provider);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function planPackageLinks(definitions, intents = []) {
     const definitionsByPath = new Map(definitions.map((definition) => [definition.path, definition]));
     const manifestDependenciesByPackagePath = new Map();
@@ -85,6 +96,30 @@ export function packageTurboTasks({ dependencyBuildsRequired, }) {
         "fix:run": { cache: false },
     };
 }
+// Boundary violations are architecture problems. Do not loosen these rules to
+// make a failing dependency graph pass; fix the dependency direction instead.
+export function generatedRepositoryTurboBoundaries() {
+    return {
+        tags: {
+            app: {
+                dependencies: {
+                    deny: ["app"],
+                },
+            },
+            library: {
+                dependencies: {
+                    deny: ["app"],
+                },
+            },
+        },
+    };
+}
+export function packageTurboConfig(options) {
+    return {
+        tasks: packageTurboTasks(options),
+        boundaries: generatedRepositoryTurboBoundaries(),
+    };
+}
 export function packageManifestExposureFields(exposure) {
     switch (exposure.kind) {
         case "jit-source":

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

@@ -1,8 +1,8 @@
-import type { BuiltInPreset, PresetSourceFixtureMatrixContract, PresetSourceManifest, PresetSourceManifestPreset, PresetSourceManifestPresetSource, PresetSourceManifestSharedResource, ValidationResult } from "@ykdz/template-shared";
+import type { BuiltInPreset, PresetSourceManifest, PresetSourceManifestPreset, PresetSourceManifestPresetSource, PresetSourceManifestSharedResource, ValidationResult } from "@ykdz/template-shared";
 import { presetSourceManifestJsonSchema } from "@ykdz/template-shared";
 import { type TemplateDependencyCatalog } from "./dependency-catalog.js";
 export { presetSourceManifestJsonSchema };
-export type { BuiltInPreset, PresetSourceFixtureMatrixContract, PresetSourceManifest, PresetSourceManifestPreset, PresetSourceManifestPresetSource, PresetSourceManifestSharedResource, };
+export type { BuiltInPreset, PresetSourceManifest, PresetSourceManifestPreset, PresetSourceManifestPresetSource, PresetSourceManifestSharedResource, };
 export type PresetSourceManifestValidationOptions = {
     readonly sourceRoot?: string;
     readonly dependencyCatalog?: TemplateDependencyCatalog;