@ykdz/template 0.0.22 → 0.0.24

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

@@ -1,572 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, readdir, readFile, stat, writeFile } 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 = {
-    TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
-};
-const defaultFixtureConcurrency = 2;
-const scenarioFingerprintVersion = 1;
-const storedBlueprintSchema = v.object({
-    packages: v.optional(v.array(v.object({
-        name: v.string(),
-        path: v.string(),
-    }))),
-});
-export function generatedScenarioChildProcessEnv(env = {}) {
-    const childEnv = { ...process.env, ...env };
-    if (childEnv.NO_COLOR !== undefined && childEnv.FORCE_COLOR !== undefined) {
-        delete childEnv.FORCE_COLOR;
-    }
-    return childEnv;
-}
-function cliSourceExecutionEnv(options, env = {}) {
-    return {
-        ...env,
-        TSX_TSCONFIG_PATH: path.join(options.repoRoot, "tsconfig.json"),
-    };
-}
-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 createGeneratedScenario(set, input) {
-    return {
-        set,
-        basePreset: input.basePreset,
-        ...(input.addedPreset === undefined
-            ? {}
-            : { addedPreset: input.addedPreset }),
-        ...(input.linkFrom === undefined ? {} : { linkFrom: [...input.linkFrom] }),
-        id: generatedScenarioId(input),
-        label: generatedScenarioLabel(input),
-    };
-}
-export function selectGeneratedScenarios(manifest, set) {
-    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 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, ...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/");
-}
-function scenarioFingerprintPrefix(scenario) {
-    return JSON.stringify({
-        version: scenarioFingerprintVersion,
-        scenario,
-        platform: process.platform,
-        arch: process.arch,
-        nodeMajor: process.versions.node.split(".")[0],
-        qualityGateProtocol: "lockfile-only-snapshot-then-fix-check",
-    });
-}
-async function hashGeneratedScenarioDirectory(scenario, projectDir) {
-    const hash = createHash("sha256");
-    hash.update(scenarioFingerprintPrefix(scenario));
-    await hashDirectoryEntries(projectDir, projectDir, hash);
-    return hash.digest("hex");
-}
-async function hashDirectoryEntries(rootDir, currentDir, hash) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
-        if (entry.name === "node_modules" || entry.name === ".git") {
-            continue;
-        }
-        const entryPath = path.join(currentDir, entry.name);
-        const relativePath = path
-            .relative(rootDir, entryPath)
-            .split(path.sep)
-            .join("/");
-        if (entry.isDirectory()) {
-            hash.update(`dir\0${relativePath}\0`);
-            await hashDirectoryEntries(rootDir, entryPath, hash);
-            continue;
-        }
-        if (!entry.isFile()) {
-            const fileStat = await stat(entryPath);
-            hash.update(`special\0${relativePath}\0${fileStat.mode.toString(8)}\0`);
-            continue;
-        }
-        const fileStat = await stat(entryPath);
-        hash.update(`file\0${relativePath}\0${fileStat.mode.toString(8)}\0`);
-        hash.update(await readFile(entryPath));
-        hash.update("\0");
-    }
-}
-async function scenarioReplayMarkerExists(cache, fingerprint) {
-    try {
-        await readFile(path.join(cache.directory, `${fingerprint}.passed`), "utf8");
-        return true;
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-async function writeScenarioReplayMarker(cache, fingerprint, scenario) {
-    await mkdir(cache.directory, { recursive: true });
-    await writeFile(path.join(cache.directory, `${fingerprint}.passed`), `${JSON.stringify({ scenario, fingerprint })}\n`, "utf8");
-}
-export function packageLeafNameForAddedPreset(manifest, 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`);
-    }
-    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}] ` : "";
-    console.log(`${prefix}$ ${[command, ...args].join(" ")}`);
-    await execa(command, [...args], {
-        cwd,
-        env: generatedScenarioChildProcessEnv(options.env),
-        extendEnv: false,
-        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: cliSourceExecutionEnv(options, 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, {
-        env: cliSourceExecutionEnv(options),
-        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.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));
-            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 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}`);
-    }
-    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,
-        ...(packageScope === undefined ? {} : { scope: packageScope }),
-    });
-    return projectPresetSourcePreset({
-        preset,
-        sourceRoots: options.projectionSourceRoots,
-        context: assembleGenerationContext({
-            targetDir: projectDir,
-            blueprint,
-            toolchain: {
-                nodeLtsMajor: { kind: "NodeLtsMajor", value: "24" },
-                packageManagerPin: { kind: "PackageManagerPin", value: "pnpm@10.34.4" },
-                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) => {
-        return {
-            id: step.id,
-            command: step.command,
-            args: step.args,
-            cwd: step.cwd,
-            display: step.display,
-            ...(step.environmentNeedKind === undefined
-                ? {}
-                : { environmentNeedKind: step.environmentNeedKind }),
-        };
-    });
-}
-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 playwrightBrowserAssetsEnvironmentNeed({
-            browser: need.browser,
-            owner: { kind: "package-boundary", path: addedPackagePath },
-            machineVerifiable: need.nextStep.machineVerifiable,
-        });
-    });
-}
-function environmentNeedStep(need, projectDir) {
-    return {
-        id: need.nextStep.id,
-        command: need.nextStep.command,
-        args: [...need.nextStep.args],
-        cwd: projectDir,
-        display: need.nextStep.display,
-        environmentNeedKind: need.kind,
-    };
-}
-export function generatedScenarioEnvironmentNeedSteps(needs, projectDir) {
-    return needs
-        .filter((need) => need.nextStep.machineVerifiable)
-        .map((need) => environmentNeedStep(need, projectDir));
-}
-export function generatedScenarioRequiresSerializedRootCheck(steps) {
-    return steps.some((step) => step.environmentNeedKind === "playwright-browser-assets");
-}
-export function generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options) {
-    const normalizedOptions = normalizeRunnerOptions(options);
-    const steps = machineVerifiableNextStepsForPreset(scenario.basePreset, projectDir, manifest, normalizedOptions);
-    const addedEnvironmentSteps = generatedScenarioEnvironmentNeedSteps(addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, normalizedOptions), 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 = generatedScenarioRequiresSerializedRootCheck(steps);
-    let replayFingerprint;
-    for (const step of steps) {
-        if (step.id === "install-dependencies") {
-            const installResult = await runGeneratedScenarioInstallStep(step, scenario, options);
-            replayFingerprint = installResult.fingerprint;
-            if (installResult.replayed) {
-                return;
-            }
-            continue;
-        }
-        const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
-        const runStep = async () => {
-            await options.runCommand(step.command, [...step.args], step.cwd, {
-                ...(env === undefined ? {} : { env }),
-                logPrefix: scenario.label,
-            });
-        };
-        if (step.id === "run-root-check" && requiresSerializedPlaywrightRootCheck) {
-            await options.rootCheckLock.run(runStep);
-            continue;
-        }
-        await runStep();
-    }
-    if (options.replayCache?.write && replayFingerprint !== undefined) {
-        await writeScenarioReplayMarker(options.replayCache, replayFingerprint, scenario);
-        options.reporter.info?.(`-- Stored passed fixture replay marker for ${scenario.label}: ${replayFingerprint}`);
-    }
-}
-async function runGeneratedScenarioInstallStep(step, scenario, options) {
-    await options.runCommand(step.command, ["install", "--lockfile-only", "--prefer-offline", "--no-frozen-lockfile"], step.cwd, { logPrefix: scenario.label });
-    let replayFingerprint;
-    if (options.replayCache) {
-        replayFingerprint = await hashGeneratedScenarioDirectory(scenario, step.cwd);
-        if (options.replayCache.read &&
-            (await scenarioReplayMarkerExists(options.replayCache, replayFingerprint))) {
-            options.reporter.info?.(`-- Replayed passed fixture ${scenario.label}: ${replayFingerprint}`);
-            return { fingerprint: replayFingerprint, replayed: true };
-        }
-    }
-    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 });
-    return { fingerprint: replayFingerprint, replayed: false };
-}
-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,
-        projectionSourceRoots: options.projectionSourceRoots,
-        runCommand: options.runCommand ?? defaultGeneratedScenarioCommandRunner,
-        reporter: options.reporter ?? {
-            info: console.log,
-            error: console.error,
-        },
-        deterministicToolchainEnv: options.deterministicToolchainEnv ?? defaultDeterministicToolchainEnv,
-        rootCheckLock: options.rootCheckLock ?? createExclusiveLock(),
-        replayCache: options.replayCache,
-    };
-}
-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/node_modules/@ykdz/template-core/dist/generation-context.d.ts

@@ -1,23 +0,0 @@
-import type { PackageManager, ProjectBlueprint } from "@ykdz/template-shared";
-import type { ResolvedToolchainVersions } from "./toolchain-resolution.js";
-export type ProjectName = {
-    readonly kind: "ProjectName";
-    readonly value: string;
-};
-export type GenerationPackageManager = {
-    readonly kind: "PackageManager";
-    readonly value: PackageManager;
-};
-export type GenerationContext = {
-    readonly projectName: ProjectName;
-    readonly preset: string;
-    readonly packageManager?: GenerationPackageManager;
-    readonly blueprint: ProjectBlueprint;
-    readonly toolchain: ResolvedToolchainVersions;
-};
-export type AssembleGenerationContextOptions = {
-    readonly targetDir: string;
-    readonly blueprint: ProjectBlueprint;
-    readonly toolchain: ResolvedToolchainVersions;
-};
-export declare function assembleGenerationContext(options: AssembleGenerationContextOptions): GenerationContext;

package/node_modules/@ykdz/template-core/dist/generation-context.js

@@ -1,20 +0,0 @@
-import path from "node:path";
-export function assembleGenerationContext(options) {
-    return {
-        projectName: {
-            kind: "ProjectName",
-            value: path.basename(path.resolve(options.targetDir)),
-        },
-        preset: options.blueprint.preset,
-        ...(options.blueprint.packageManager
-            ? {
-                packageManager: {
-                    kind: "PackageManager",
-                    value: options.blueprint.packageManager,
-                },
-            }
-            : {}),
-        blueprint: options.blueprint,
-        toolchain: options.toolchain,
-    };
-}

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

@@ -1,30 +0,0 @@
-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;
-    readonly kind: "navigation" | "command";
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly display: string;
-    readonly machineVerifiable: boolean;
-    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"];
-};
-export type NextStepInstructionPlan = {
-    readonly targetDir: string;
-    readonly steps: readonly NextStepInstruction[];
-};
-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;