@ykdz/template 0.0.23 → 0.0.25

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

@@ -1,75 +0,0 @@
-import type { PackageLinkIntent, PackageRole, PackageSourcePreset } from "@ykdz/template-shared";
-export type { PackageLinkIntent, PackageRole, PackageSourcePreset, } from "@ykdz/template-shared";
-export type PackageDefinition = {
-    readonly name: string;
-    readonly path: string;
-    readonly role?: PackageRole;
-    readonly sourcePreset?: PackageSourcePreset;
-};
-export type JitSourcePackageExposure = {
-    readonly kind: "jit-source";
-    readonly entrypoint: string;
-    readonly packageLocalImportPattern: string;
-    readonly packageLocalImportTarget: string;
-};
-export type CompiledPackageExposure = {
-    readonly kind: "compiled";
-    readonly entrypoint: string;
-    readonly sourceTypes: string;
-    readonly packageLocalImportPattern: string;
-    readonly packageLocalImportRuntimeTarget: string;
-    readonly packageLocalImportTypesTarget: string;
-};
-export type PackageExposure = CompiledPackageExposure | JitSourcePackageExposure;
-export type PackageLinkPlan = {
-    readonly exposuresByPackagePath: ReadonlyMap<string, PackageExposure>;
-    readonly manifestDependenciesByPackagePath: ReadonlyMap<string, Readonly<Record<string, "workspace:*">>>;
-    readonly turboTasks: TurboTaskGraph;
-};
-export type PackageManifestExposureFields = {
-    readonly exports: Record<string, unknown>;
-    readonly imports: Record<string, unknown>;
-    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;
-};
-export declare function derivePackageExposure(definition: PackageDefinition): PackageExposure;
-export declare function assertTypeScriptPackageBoundaryForLinkIntent(definition: PackageDefinition, direction: PackageLinkBoundaryDirection): asserts definition is PackageDefinition & {
-    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

@@ -1,157 +0,0 @@
-export function derivePackageExposure(definition) {
-    if (definition.role === "shared-library" &&
-        definition.sourcePreset === "ts-lib") {
-        return {
-            kind: "jit-source",
-            entrypoint: "./src/index.ts",
-            packageLocalImportPattern: "#/*",
-            packageLocalImportTarget: "./src/*.ts",
-        };
-    }
-    if (definition.role === "runtime-service" &&
-        definition.sourcePreset === "hono-api") {
-        return {
-            kind: "compiled",
-            entrypoint: "./dist/index.js",
-            sourceTypes: "./src/index.ts",
-            packageLocalImportPattern: "#/*",
-            packageLocalImportRuntimeTarget: "./dist/*.js",
-            packageLocalImportTypesTarget: "./src/*.ts",
-        };
-    }
-    throw new Error(`Unsupported Package Exposure for ${definition.name} at ${definition.path}`);
-}
-export function assertTypeScriptPackageBoundaryForLinkIntent(definition, direction) {
-    if (definition.role !== undefined && definition.sourcePreset !== undefined) {
-        return;
-    }
-    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();
-    for (const intent of intents) {
-        const consumer = definitionsByPath.get(intent.consumerPackagePath);
-        const provider = definitionsByPath.get(intent.providerPackagePath);
-        if (consumer !== undefined) {
-            assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
-        }
-        if (provider === undefined) {
-            throw new Error(`Package Link Intent references unknown provider package at ${intent.providerPackagePath}`);
-        }
-        assertTypeScriptPackageBoundaryForLinkIntent(provider, "provider");
-    }
-    const exposuresByPackagePath = new Map(definitions.map((definition) => [
-        definition.path,
-        derivePackageExposure(definition),
-    ]));
-    let dependencyBuildsRequired = false;
-    for (const intent of intents) {
-        const provider = definitionsByPath.get(intent.providerPackagePath);
-        if (provider === undefined) {
-            throw new Error(`Package Link Intent references unknown provider package at ${intent.providerPackagePath}`);
-        }
-        if (exposuresByPackagePath.get(provider.path)?.kind === "compiled") {
-            dependencyBuildsRequired = true;
-        }
-        const dependencies = manifestDependenciesByPackagePath.get(intent.consumerPackagePath) ?? {};
-        dependencies[provider.name] = "workspace:*";
-        manifestDependenciesByPackagePath.set(intent.consumerPackagePath, dependencies);
-    }
-    return {
-        exposuresByPackagePath,
-        manifestDependenciesByPackagePath,
-        turboTasks: packageTurboTasks({ dependencyBuildsRequired }),
-    };
-}
-export function packageTurboTasks({ dependencyBuildsRequired, }) {
-    return {
-        "format:check:run": {},
-        "format:write:run": { cache: false },
-        "lint:run": {},
-        "lint:fix:run": { cache: false },
-        "typecheck:run": { dependsOn: ["^typecheck:run"] },
-        "build:run": dependencyBuildsRequired
-            ? { dependsOn: ["^build:run"], outputs: ["dist/**"] }
-            : { outputs: ["dist/**"] },
-        "test:run": { dependsOn: ["^typecheck:run"] },
-        "test:e2e:run": {
-            dependsOn: dependencyBuildsRequired
-                ? ["build:run", "^build:run"]
-                : ["build:run"],
-        },
-        "check:run": { cache: false },
-        "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":
-            return {
-                imports: {
-                    [exposure.packageLocalImportPattern]: {
-                        default: exposure.packageLocalImportTarget,
-                        types: exposure.packageLocalImportTarget,
-                    },
-                },
-                exports: {
-                    ".": {
-                        default: exposure.entrypoint,
-                        types: exposure.entrypoint,
-                    },
-                },
-            };
-        case "compiled":
-            return {
-                types: exposure.sourceTypes,
-                imports: {
-                    [exposure.packageLocalImportPattern]: {
-                        default: exposure.packageLocalImportRuntimeTarget,
-                        types: exposure.packageLocalImportTypesTarget,
-                    },
-                },
-                exports: {
-                    ".": {
-                        default: exposure.entrypoint,
-                        types: exposure.sourceTypes,
-                    },
-                },
-            };
-    }
-}

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

@@ -1,68 +0,0 @@
-import type { BuiltInPreset, PackageRole, PackageSourcePreset, ProjectBlueprint } from "@ykdz/template-shared";
-import type { GenerationContext } from "./generation-context.js";
-import { type CheckPlan, type FixPlan } from "./module-graph.js";
-import { type NextStepInstruction } from "./next-step-instructions.js";
-import type { DependencyMaintenancePolicy } from "./project-github.js";
-import type { RenderOperation } from "./renderer.js";
-export type PresetPackageAdditionOptions = {
-    readonly root: string;
-    readonly blueprint: ProjectBlueprint;
-    readonly packageLeafName: string;
-    readonly packageName: string;
-    readonly packagePath: string;
-    readonly nodeVersion: string;
-};
-export type PresetPackageAdditionPlan = {
-    readonly packagePath: string;
-    readonly workspacePackageGlob: string;
-    readonly workspaceMembershipGlob?: string;
-    readonly packageRole: PackageRole;
-    readonly packageSourcePreset: PackageSourcePreset;
-    readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string> | undefined;
-    readonly operations: readonly RenderOperation[];
-    readonly textFiles?: readonly {
-        readonly path: string;
-        readonly text: string;
-    }[];
-};
-export type PresetPackageAdditionCapability = {
-    planPackageAddition(options: PresetPackageAdditionOptions): PresetPackageAdditionPlan | Promise<PresetPackageAdditionPlan>;
-};
-export type PresetProjectionPlan = {
-    readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string> | undefined;
-    readonly operations: readonly RenderOperation[];
-    readonly checkPlan: CheckPlan;
-    readonly fixPlan: FixPlan;
-    readonly dependencyMaintenancePolicy: DependencyMaintenancePolicy;
-    readonly packageScripts: Record<string, string>;
-    readonly capabilities: {
-        readonly rootCheck: true;
-        readonly fixCommand: true;
-        readonly githubActions: true;
-        readonly dependabot: true;
-        readonly devcontainer: true;
-    };
-};
-export type PresetBlueprintOptions = {
-    readonly targetDir: string;
-    readonly scope?: string | undefined;
-};
-export type RenderPresetProjectionOptions = {
-    readonly targetDir: string;
-    readonly plan: PresetProjectionPlan;
-};
-export type PresetProjection = {
-    readonly metadata: BuiltInPreset;
-    readonly capabilities?: {
-        readonly packageAddition?: PresetPackageAdditionCapability;
-    };
-    blueprint(options: PresetBlueprintOptions): ProjectBlueprint;
-    project(context: GenerationContext): PresetProjectionPlan;
-    render(options: RenderPresetProjectionOptions): Promise<void>;
-};
-export declare function planNextStepInstructionsForProjection(options: {
-    readonly targetDir: string;
-    readonly plan: PresetProjectionPlan;
-}): readonly NextStepInstruction[];

package/node_modules/@ykdz/template-core/dist/preset-projection.js

@@ -1,8 +0,0 @@
-import {} from "./module-graph.js";
-import { planNextStepInstructions, } from "./next-step-instructions.js";
-export function planNextStepInstructionsForProjection(options) {
-    return planNextStepInstructions({
-        targetDir: options.targetDir,
-        projectionPlan: options.plan,
-    }).steps;
-}

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

@@ -1,14 +0,0 @@
-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, PresetSourceManifest, PresetSourceManifestPreset, PresetSourceManifestPresetSource, PresetSourceManifestSharedResource, };
-export type PresetSourceManifestValidationOptions = {
-    readonly sourceRoot?: string;
-    readonly dependencyCatalog?: TemplateDependencyCatalog;
-};
-export declare function validatePresetSourceManifest(input: unknown, options?: PresetSourceManifestValidationOptions): ValidationResult<PresetSourceManifest>;
-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 findPresetSourceManifestPreset(manifest: PresetSourceManifest, presetName: string): PresetSourceManifestPreset | undefined;

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

@@ -1,294 +0,0 @@
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
-import path from "node:path";
-import { presetSourceManifestJsonSchema, validatePresetSourceManifestDeclaration, } from "@ykdz/template-shared";
-import { loadTemplateDependencyCatalog, } from "./dependency-catalog.js";
-export { presetSourceManifestJsonSchema };
-function dependencyCatalogReferenceIssues(presets, dependencyCatalog) {
-    return presets.flatMap((preset, fallbackPresetIndex) => {
-        const presetIndex = preset.manifestIndex ?? fallbackPresetIndex;
-        return (preset.dependencyCatalog ?? [])
-            .filter((dependency) => dependencyCatalog[dependency] === undefined)
-            .map((dependency) => ({
-            path: `$.presets[${presetIndex}].dependencyCatalog`,
-            message: `Preset ${preset.name} references missing Template Dependency Catalog entry: ${dependency}`,
-        }));
-    });
-}
-function resolvePresetSourcePath(sourceRoot, referencePath) {
-    if (path.isAbsolute(referencePath)) {
-        return { issue: `Preset Source paths must be relative: ${referencePath}` };
-    }
-    const resolvedRoot = path.resolve(sourceRoot);
-    const resolvedPath = path.resolve(resolvedRoot, referencePath);
-    const insideRoot = resolvedPath === resolvedRoot ||
-        resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
-    if (!insideRoot) {
-        return {
-            issue: `Preset Source path escapes its source boundary: ${referencePath}`,
-        };
-    }
-    return resolvedPath;
-}
-function realPresetSourcePathIssue(sourceRoot, referencePath, resolvedPath) {
-    const realRoot = realpathSync(sourceRoot);
-    const realPath = realpathSync(resolvedPath);
-    const insideRoot = realPath === realRoot || realPath.startsWith(`${realRoot}${path.sep}`);
-    return insideRoot
-        ? undefined
-        : `Preset Source path escapes its source boundary: ${referencePath}`;
-}
-function sharedResourcePathIssues(manifest, sourceRoot) {
-    if (sourceRoot === undefined) {
-        return [];
-    }
-    return manifest.sharedResources.flatMap((resource, fallbackResourceIndex) => {
-        const resourceIndex = resource.manifestIndex ?? fallbackResourceIndex;
-        const resolvedPath = resolvePresetSourcePath(sourceRoot, resource.path);
-        if (typeof resolvedPath !== "string") {
-            return [
-                {
-                    path: `$.sharedResources[${resourceIndex}].path`,
-                    message: resolvedPath.issue,
-                },
-            ];
-        }
-        if (!existsSync(resolvedPath)) {
-            return [
-                {
-                    path: `$.sharedResources[${resourceIndex}].path`,
-                    message: `Shared Resource ${resource.id} path does not exist: ${resource.path}`,
-                },
-            ];
-        }
-        const realPathIssue = realPresetSourcePathIssue(sourceRoot, resource.path, resolvedPath);
-        if (realPathIssue) {
-            return [
-                {
-                    path: `$.sharedResources[${resourceIndex}].path`,
-                    message: realPathIssue,
-                },
-            ];
-        }
-        return [];
-    });
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isDependencySemverSpecifier(value) {
-    return /^(?:[~^]|[<>=]=?)?\d+(?:\.\d+){0,2}(?:[-+][\w.-]+)?(?:\s|$|\|\|)/.test(value);
-}
-function inlineDependencyCatalogSpecifierIssues(input) {
-    if (!isRecord(input) || !Array.isArray(input.presets)) {
-        return [];
-    }
-    return input.presets.flatMap((preset, presetIndex) => {
-        if (!isRecord(preset)) {
-            return [];
-        }
-        if (Array.isArray(preset.dependencyCatalog)) {
-            return preset.dependencyCatalog.flatMap((specifier, dependencyIndex) => typeof specifier === "string" && isDependencySemverSpecifier(specifier)
-                ? [
-                    {
-                        path: `$.presets[${presetIndex}].dependencyCatalog[${dependencyIndex}]`,
-                        message: `Preset Source Manifests must reference Template Dependency Catalog entries by name, not inline semver specifier ${specifier}`,
-                    },
-                ]
-                : []);
-        }
-        if (!isRecord(preset.dependencyCatalog)) {
-            return [];
-        }
-        return Object.entries(preset.dependencyCatalog)
-            .filter((entry) => typeof entry[1] === "string" && isDependencySemverSpecifier(entry[1]))
-            .map(([dependency, specifier]) => ({
-            path: `$.presets[${presetIndex}].dependencyCatalog.${dependency}`,
-            message: `Preset Source Manifests must reference Template Dependency Catalog entries by name, not inline semver specifier ${specifier}`,
-        }));
-    });
-}
-function stringArray(value) {
-    return Array.isArray(value) &&
-        value.every((item) => typeof item === "string")
-        ? value
-        : undefined;
-}
-function corePresetSourceFromUnknown(source) {
-    if (!isRecord(source)) {
-        return undefined;
-    }
-    return {
-        roots: stringArray(source.roots) ?? [],
-        files: stringArray(source.files) ?? [],
-        sharedResources: stringArray(source.sharedResources) ?? [],
-    };
-}
-function coreSemanticManifestFromUnknown(input) {
-    if (!isRecord(input)) {
-        return undefined;
-    }
-    const sharedResources = Array.isArray(input.sharedResources)
-        ? input.sharedResources.flatMap((resource, manifestIndex) => isRecord(resource) &&
-            typeof resource.id === "string" &&
-            typeof resource.path === "string"
-            ? [{ id: resource.id, path: resource.path, manifestIndex }]
-            : [])
-        : [];
-    const presets = Array.isArray(input.presets)
-        ? input.presets.flatMap((preset, manifestIndex) => {
-            if (!isRecord(preset) || typeof preset.name !== "string") {
-                return [];
-            }
-            const source = corePresetSourceFromUnknown(preset.source);
-            return [
-                {
-                    manifestIndex,
-                    name: preset.name,
-                    dependencyCatalog: stringArray(preset.dependencyCatalog) ?? [],
-                    ...(source === undefined ? {} : { source }),
-                },
-            ];
-        })
-        : [];
-    return { sharedResources, presets };
-}
-function presetSourceReferenceIssues(manifest, sourceRoot) {
-    const sharedResourceIds = new Set(manifest.sharedResources.map((resource) => resource.id));
-    return manifest.presets.flatMap((preset, fallbackPresetIndex) => {
-        const presetIndex = preset.manifestIndex ?? fallbackPresetIndex;
-        const source = preset.source;
-        if (!source) {
-            return [];
-        }
-        const sharedResourceIssues = source.sharedResources
-            .filter((resourceId) => !sharedResourceIds.has(resourceId))
-            .map((resourceId) => ({
-            path: `$.presets[${presetIndex}].source.sharedResources`,
-            message: `Preset ${preset.name} references undeclared Shared Resource: ${resourceId}`,
-        }));
-        const pathIssues = sourceRoot === undefined
-            ? []
-            : [
-                ...source.roots.map((sourcePath, index) => ({
-                    path: `$.presets[${presetIndex}].source.roots[${index}]`,
-                    sourcePath,
-                    kind: "source root",
-                })),
-                ...source.files.map((sourcePath, index) => ({
-                    path: `$.presets[${presetIndex}].source.files[${index}]`,
-                    sourcePath,
-                    kind: "source file",
-                })),
-            ].flatMap(({ path: issuePath, sourcePath, kind }) => {
-                const resolvedPath = resolvePresetSourcePath(sourceRoot, sourcePath);
-                if (typeof resolvedPath !== "string") {
-                    return [{ path: issuePath, message: resolvedPath.issue }];
-                }
-                if (!existsSync(resolvedPath)) {
-                    return [
-                        {
-                            path: issuePath,
-                            message: `Preset ${preset.name} ${kind} does not exist: ${sourcePath}`,
-                        },
-                    ];
-                }
-                const realPathIssue = realPresetSourcePathIssue(sourceRoot, sourcePath, resolvedPath);
-                if (realPathIssue) {
-                    return [{ path: issuePath, message: realPathIssue }];
-                }
-                return [];
-            });
-        return [...sharedResourceIssues, ...pathIssues];
-    });
-}
-function coreSemanticIssues(manifest, options) {
-    return [
-        ...dependencyCatalogReferenceIssues(manifest.presets, options.dependencyCatalog ?? loadTemplateDependencyCatalog()),
-        ...sharedResourcePathIssues(manifest, options.sourceRoot),
-        ...presetSourceReferenceIssues(manifest, options.sourceRoot),
-    ];
-}
-function supportedProjectionDeclarationIssues(presets) {
-    return presets.flatMap((preset, index) => preset.generation === "supported" && preset.projection === undefined
-        ? [
-            {
-                path: `$.presets[${index}].projection`,
-                message: `Supported Preset ${preset.name} must declare a Projection Declaration`,
-            },
-        ]
-        : []);
-}
-export function validatePresetSourceManifest(input, options = {}) {
-    const inlineDependencyIssues = inlineDependencyCatalogSpecifierIssues(input);
-    if (inlineDependencyIssues.length > 0) {
-        return { ok: false, issues: inlineDependencyIssues };
-    }
-    const result = validatePresetSourceManifestDeclaration(input);
-    const manifest = result.ok
-        ? result.value
-        : coreSemanticManifestFromUnknown(input);
-    const semanticIssues = manifest ? coreSemanticIssues(manifest, options) : [];
-    if (!result.ok || semanticIssues.length > 0) {
-        return {
-            ok: false,
-            issues: [...(result.ok ? [] : result.issues), ...semanticIssues],
-        };
-    }
-    return {
-        ok: true,
-        value: result.value,
-    };
-}
-export function validateBuiltInPresetSourceManifest(input, options = {}) {
-    const result = validatePresetSourceManifest(input, options);
-    if (!result.ok) {
-        return result;
-    }
-    const projectionIssues = supportedProjectionDeclarationIssues(result.value.presets);
-    if (projectionIssues.length > 0) {
-        return { ok: false, issues: projectionIssues };
-    }
-    return result;
-}
-function listPresetSourceFiles(sourcePath) {
-    const stats = statSync(sourcePath);
-    if (stats.isFile()) {
-        return [sourcePath];
-    }
-    if (!stats.isDirectory()) {
-        return [];
-    }
-    return readdirSync(sourcePath, { withFileTypes: true }).flatMap((entry) => listPresetSourceFiles(path.join(sourcePath, entry.name)));
-}
-export function manifestReferencedSourceFiles(manifest, sourceRoot) {
-    const files = new Set();
-    function addReference(referencePath) {
-        for (const file of listPresetSourceFiles(path.resolve(sourceRoot, referencePath))) {
-            files.add(file);
-        }
-    }
-    for (const resource of manifest.sharedResources) {
-        addReference(resource.path);
-    }
-    for (const preset of manifest.presets) {
-        for (const root of preset.source?.roots ?? []) {
-            addReference(root);
-        }
-        for (const file of preset.source?.files ?? []) {
-            addReference(file);
-        }
-    }
-    return [...files].toSorted();
-}
-export function loadPresetSourceManifestFile(filePath) {
-    const result = validatePresetSourceManifest(JSON.parse(readFileSync(filePath, "utf8")), { sourceRoot: path.dirname(filePath) });
-    if (!result.ok) {
-        throw new Error(`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);
-}

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

@@ -1,31 +0,0 @@
-import type { GithubMaintenanceCapabilityDeclaration, NodePnpmDevcontainerCapabilityDeclaration, ProjectBlueprint, ProjectionCapabilityDeclaration, ProjectionCapabilityKind, OxcFormatLintCapabilityDeclaration, PresetProjectionDeclaration, RustBinaryWorkspaceCapabilityDeclaration, StrictTypescriptRootCapabilityDeclaration, WorkspaceLibraryPackageCapabilityDeclaration, WorkspaceNodePackageDeclaration, WorkspaceNodePackageKind, WorkspaceNodePackagesCapabilityDeclaration, WorkspaceNodePackagePath } from "@ykdz/template-shared";
-import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validatePresetProjectionDeclaration as validateProjectionCapabilities } from "@ykdz/template-shared";
-import type { GenerationContext } from "./generation-context.js";
-import type { PresetBlueprintOptions, PresetPackageAdditionOptions, PresetPackageAdditionPlan, PresetProjectionPlan } from "./preset-projection.js";
-import type { PresetSourceManifestPreset } from "./preset-source.js";
-export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
-export type { GithubMaintenanceCapabilityDeclaration, NodePnpmDevcontainerCapabilityDeclaration, OxcFormatLintCapabilityDeclaration, PresetProjectionDeclaration, ProjectionCapabilityDeclaration, ProjectionCapabilityKind, RustBinaryWorkspaceCapabilityDeclaration, StrictTypescriptRootCapabilityDeclaration, WorkspaceLibraryPackageCapabilityDeclaration, WorkspaceNodePackageDeclaration, WorkspaceNodePackageKind, WorkspaceNodePackagesCapabilityDeclaration, WorkspaceNodePackagePath, };
-export type ProjectionSourcePreset = "hono-api" | "rust-bin" | "ts-lib" | "vike-app" | "vue-app" | "vue-hono-app";
-export type PresetProjectionSourceRoots = {
-    readonly preset: (sourcePreset: ProjectionSourcePreset) => string;
-    readonly sharedOxc: () => string;
-    readonly sharedResource: (resourceId: string) => string | undefined;
-};
-export declare function interpretPresetProjectionDeclaration(options: {
-    readonly preset: PresetSourceManifestPreset;
-    readonly declaration: PresetProjectionDeclaration;
-    readonly context: GenerationContext;
-    readonly sourceRoots: PresetProjectionSourceRoots;
-}): PresetProjectionPlan;
-export declare function blueprintForPresetSourcePreset(preset: PresetSourceManifestPreset, options?: PresetBlueprintOptions): ProjectBlueprint;
-export declare function projectPresetSourcePreset(options: {
-    readonly preset: PresetSourceManifestPreset;
-    readonly context: GenerationContext;
-    readonly sourceRoots: PresetProjectionSourceRoots;
-}): PresetProjectionPlan;
-export declare function planPresetSourcePackageAddition(options: {
-    readonly preset: PresetSourceManifestPreset;
-    readonly addition: PresetPackageAdditionOptions;
-    readonly sourceRoots: PresetProjectionSourceRoots;
-}): Promise<PresetPackageAdditionPlan>;
-export declare function defaultPackagePathForPresetSourcePackageAddition(preset: PresetSourceManifestPreset, packageLeafName: string, sourceRoots: PresetProjectionSourceRoots): string;