@ykdz/template 0.0.9 → 0.0.11

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

@@ -1,651 +1,18 @@
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
 import path from "node:path";
-import * as v from "valibot";
+import { presetSourceManifestJsonSchema, validatePresetSourceManifestDeclaration, } from "@ykdz/template-shared";
 import { loadTemplateDependencyCatalog, } from "./dependency-catalog.js";
-import { PackageAdditionSupport } from "./package-addition-support.js";
-import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, } from "./projection-capabilities.js";
-const featureNames = [
-    "pnpm-catalog",
-    "oxc-format-lint",
-    "strict-typescript",
-    "root-check",
-    "fix-command",
-    "devcontainer",
-    "github-actions",
-    "dependabot",
-    "rustfmt-clippy",
-    "cargo-test",
-    "native-binary-release",
-];
-const packageLeafNamePattern = "^[a-z0-9][a-z0-9-]*$";
-const packageLeafNameRegExp = new RegExp(packageLeafNamePattern);
-const requiredFixtureMatrixCheckRequirements = [
-    "machine-verifiable-next-steps",
-    "root-check-ci",
-];
-const requiredFixtureMatrixEnvironmentPreparation = [
-    "playwright-browser-assets",
-];
-export const presetSourceManifestJsonSchema = {
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://ykdz.dev/schemas/template/preset-source-manifest.schema.json",
-    title: "Preset Source Manifest",
-    type: "object",
-    additionalProperties: false,
-    required: ["schemaVersion", "name", "presets"],
-    properties: {
-        schemaVersion: { const: 1 },
-        name: { type: "string", minLength: 1 },
-        sharedResources: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                required: ["id", "path"],
-                properties: {
-                    id: { type: "string", minLength: 1 },
-                    path: { type: "string", minLength: 1 },
-                },
-            },
-        },
-        fixtureMatrix: {
-            type: "object",
-            additionalProperties: false,
-            required: [
-                "initSupport",
-                "packageAdditionSupport",
-                "supportedCombinations",
-                "semanticSkips",
-                "checkRequirements",
-                "environmentPreparation",
-            ],
-            properties: {
-                initSupport: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["preset"],
-                        properties: {
-                            preset: { type: "string", minLength: 1 },
-                        },
-                    },
-                },
-                packageAdditionSupport: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["preset", "packageLeafName"],
-                        properties: {
-                            preset: { type: "string", minLength: 1 },
-                            packageLeafName: {
-                                type: "string",
-                                minLength: 1,
-                                pattern: packageLeafNamePattern,
-                            },
-                        },
-                    },
-                },
-                supportedCombinations: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["basePreset", "addedPreset"],
-                        properties: {
-                            basePreset: { type: "string", minLength: 1 },
-                            addedPreset: { type: "string", minLength: 1 },
-                            linkFrom: {
-                                type: "array",
-                                items: { type: "string", minLength: 1 },
-                            },
-                        },
-                    },
-                },
-                semanticSkips: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["basePreset", "addedPreset", "reason"],
-                        properties: {
-                            basePreset: { type: "string", minLength: 1 },
-                            addedPreset: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                        },
-                    },
-                },
-                checkRequirements: {
-                    type: "array",
-                    items: {
-                        enum: [...requiredFixtureMatrixCheckRequirements],
-                    },
-                    uniqueItems: true,
-                },
-                environmentPreparation: {
-                    type: "array",
-                    items: {
-                        enum: [...requiredFixtureMatrixEnvironmentPreparation],
-                    },
-                    uniqueItems: true,
-                },
-            },
-        },
-        presets: {
-            type: "array",
-            minItems: 1,
-            items: {
-                type: "object",
-                additionalProperties: false,
-                required: [
-                    "name",
-                    "title",
-                    "description",
-                    "generation",
-                    "supportedPackageManagers",
-                    "supportedProjectKinds",
-                    "packageAdditionSupport",
-                    "features",
-                ],
-                properties: {
-                    name: { type: "string", minLength: 1 },
-                    title: { type: "string", minLength: 1 },
-                    description: { type: "string", minLength: 1 },
-                    generation: { enum: ["supported", "future"] },
-                    supportedPackageManagers: {
-                        type: "array",
-                        items: { enum: ["pnpm"] },
-                        uniqueItems: true,
-                    },
-                    supportedProjectKinds: {
-                        type: "array",
-                        minItems: 1,
-                        items: { enum: ["multi-package"] },
-                        uniqueItems: true,
-                    },
-                    packageAdditionSupport: {
-                        enum: [
-                            PackageAdditionSupport.Supported,
-                            PackageAdditionSupport.Unsupported,
-                        ],
-                    },
-                    features: {
-                        type: "array",
-                        items: { enum: featureNames },
-                        uniqueItems: true,
-                    },
-                    dependencyCatalog: {
-                        type: "array",
-                        items: { type: "string", minLength: 1 },
-                        uniqueItems: true,
-                    },
-                    projection: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["capabilities"],
-                        properties: {
-                            capabilities: {
-                                type: "array",
-                                items: {
-                                    oneOf: [
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: [
-                                                "kind",
-                                                "workspacePackageGlob",
-                                                "packageRole",
-                                                "packageSourcePreset",
-                                                "sourceFiles",
-                                            ],
-                                            properties: {
-                                                kind: { const: "workspace-library-package" },
-                                                workspacePackageGlob: { const: "packages/*" },
-                                                packageRole: { const: "shared-library" },
-                                                packageSourcePreset: { const: "ts-lib" },
-                                                sourceFiles: {
-                                                    type: "array",
-                                                    minItems: 1,
-                                                    items: { type: "string", minLength: 1 },
-                                                },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind", "workspacePackageGlob", "packages"],
-                                            properties: {
-                                                kind: { const: "workspace-node-packages" },
-                                                workspacePackageGlob: { const: "apps/*" },
-                                                packages: {
-                                                    type: "array",
-                                                    minItems: 1,
-                                                    items: {
-                                                        type: "object",
-                                                        additionalProperties: false,
-                                                        required: ["kind", "path", "sourceFiles"],
-                                                        properties: {
-                                                            kind: { enum: ["hono-api", "vue-app"] },
-                                                            path: { enum: ["apps/api", "apps/web"] },
-                                                            sourceFiles: {
-                                                                type: "array",
-                                                                minItems: 1,
-                                                                items: { type: "string", minLength: 1 },
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                                packageLinks: {
-                                                    type: "array",
-                                                    items: {
-                                                        type: "object",
-                                                        additionalProperties: false,
-                                                        required: [
-                                                            "consumerPackagePath",
-                                                            "providerPackagePath",
-                                                        ],
-                                                        properties: {
-                                                            consumerPackagePath: { const: "apps/web" },
-                                                            providerPackagePath: { const: "apps/api" },
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind", "workspacePackageGlob", "sourceFiles"],
-                                            properties: {
-                                                kind: { const: "rust-binary-workspace" },
-                                                workspacePackageGlob: { const: "packages/*" },
-                                                sourceFiles: {
-                                                    type: "array",
-                                                    minItems: 1,
-                                                    items: { type: "string", minLength: 1 },
-                                                },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind"],
-                                            properties: {
-                                                kind: { const: "strict-typescript-root" },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind"],
-                                            properties: {
-                                                kind: { const: "oxc-format-lint" },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind"],
-                                            properties: {
-                                                kind: { const: "node-pnpm-devcontainer" },
-                                            },
-                                        },
-                                        {
-                                            type: "object",
-                                            additionalProperties: false,
-                                            required: ["kind"],
-                                            properties: {
-                                                kind: { const: "github-maintenance" },
-                                            },
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    },
-                    source: {
-                        type: "object",
-                        additionalProperties: false,
-                        properties: {
-                            roots: {
-                                type: "array",
-                                items: { type: "string", minLength: 1 },
-                            },
-                            files: {
-                                type: "array",
-                                items: { type: "string", minLength: 1 },
-                            },
-                            sharedResources: {
-                                type: "array",
-                                items: { type: "string", minLength: 1 },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    },
-};
-const nonEmptyString = v.pipe(v.string(), v.minLength(1));
-const packageManagerSchema = v.picklist(["pnpm"]);
-const projectKindSchema = v.picklist([
-    "single-package",
-    "multi-package",
-]);
-const packageAdditionSupportSchema = v.picklist([
-    PackageAdditionSupport.Supported,
-    PackageAdditionSupport.Unsupported,
-]);
-const featureNameSchema = v.picklist(featureNames);
-const presetSourceManifestPresetSourceSchema = v.strictObject({
-    roots: v.optional(v.array(nonEmptyString), []),
-    files: v.optional(v.array(nonEmptyString), []),
-    sharedResources: v.optional(v.array(nonEmptyString), []),
-});
-const fixtureMatrixPresetSupportSchema = v.strictObject({
-    preset: nonEmptyString,
-});
-const fixtureMatrixPackageAdditionSupportSchema = v.strictObject({
-    preset: nonEmptyString,
-    packageLeafName: v.pipe(v.string(), v.regex(packageLeafNameRegExp, "Fixture Matrix Package Addition packageLeafName must be a lowercase package leaf name using letters, numbers, and hyphens")),
-});
-const fixtureMatrixCombinationSchema = v.strictObject({
-    basePreset: nonEmptyString,
-    addedPreset: nonEmptyString,
-    linkFrom: v.optional(v.array(nonEmptyString), []),
-});
-const fixtureMatrixSemanticSkipSchema = v.strictObject({
-    basePreset: nonEmptyString,
-    addedPreset: nonEmptyString,
-    reason: nonEmptyString,
-});
-const fixtureMatrixContractSchema = v.strictObject({
-    initSupport: v.array(fixtureMatrixPresetSupportSchema),
-    packageAdditionSupport: v.array(fixtureMatrixPackageAdditionSupportSchema),
-    supportedCombinations: v.array(fixtureMatrixCombinationSchema),
-    semanticSkips: v.array(fixtureMatrixSemanticSkipSchema),
-    checkRequirements: v.array(v.picklist(requiredFixtureMatrixCheckRequirements)),
-    environmentPreparation: v.array(v.picklist(requiredFixtureMatrixEnvironmentPreparation)),
-});
-const projectionCapabilityKindSchema = v.string();
-const presetProjectionDeclarationSchema = v.strictObject({
-    capabilities: v.array(v.looseObject({
-        kind: projectionCapabilityKindSchema,
-    })),
-});
-const presetSourceManifestSchema = v.strictObject({
-    schemaVersion: v.literal(1),
-    name: nonEmptyString,
-    sharedResources: v.optional(v.array(v.strictObject({
-        id: nonEmptyString,
-        path: nonEmptyString,
-    })), []),
-    fixtureMatrix: v.optional(fixtureMatrixContractSchema),
-    presets: v.pipe(v.array(v.strictObject({
-        name: nonEmptyString,
-        title: nonEmptyString,
-        description: nonEmptyString,
-        generation: v.picklist(["supported", "future"]),
-        supportedPackageManagers: v.array(packageManagerSchema),
-        supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
-        packageAdditionSupport: packageAdditionSupportSchema,
-        features: v.array(featureNameSchema),
-        dependencyCatalog: v.optional(v.array(nonEmptyString), []),
-        projection: v.optional(presetProjectionDeclarationSchema),
-        source: v.optional(presetSourceManifestPresetSourceSchema),
-    })), v.minLength(1)),
-});
-function formatIssuePath(issue) {
-    if (!issue.path || issue.path.length === 0) {
-        return "$";
-    }
-    return issue.path.reduce((issuePath, item) => {
-        if (typeof item.key === "number") {
-            return `${issuePath}[${item.key}]`;
-        }
-        return `${issuePath}.${String(item.key)}`;
-    }, "$");
-}
-function shapeIssues(issues) {
-    return issues.map((issue) => {
-        const validationPath = formatIssuePath(issue);
-        const missingPresetMetadata = validationPath.match(/^\$\.presets\[\d+\]\.(.+)$/);
-        if (missingPresetMetadata && issue.message.includes("received undefined")) {
-            return {
-                path: validationPath,
-                message: `Preset metadata is missing required field: ${missingPresetMetadata[1]}`,
-            };
-        }
-        if (issue.message.startsWith("Invalid key:") &&
-            /\.(body|content|text)$/.test(validationPath)) {
-            const key = validationPath.split(".").at(-1);
-            return {
-                path: validationPath,
-                message: `Preset Source Manifests must reference Generated Repository file bodies by path, not inline ${key}`,
-            };
-        }
-        return {
-            path: validationPath,
-            message: validationPath.match(/^\$\.presets\[\d+\]\.packageAdditionSupport$/)
-                ? "Package Addition Support must be one of: supported, unsupported"
-                : issue.message,
-        };
-    });
-}
-function duplicatePresetNameIssues(presets) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const preset of presets) {
-        if (seen.has(preset.name)) {
-            duplicates.add(preset.name);
-        }
-        seen.add(preset.name);
-    }
-    return [...duplicates].map((name) => ({
-        path: "$.presets.name",
-        message: `Duplicate Preset name: ${name}`,
-    }));
-}
-function duplicateValueIssues(values, validationPath) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const value of values) {
-        if (seen.has(value)) {
-            duplicates.add(value);
-        }
-        seen.add(value);
-    }
-    return [...duplicates].map((value) => ({
-        path: validationPath,
-        message: `Duplicate value: ${value}`,
-    }));
-}
-function duplicatePresetMetadataArrayIssues(presets) {
-    return presets.flatMap((preset, index) => [
-        ...duplicateValueIssues(preset.supportedPackageManagers, `$.presets[${index}].supportedPackageManagers`),
-        ...duplicateValueIssues(preset.supportedProjectKinds, `$.presets[${index}].supportedProjectKinds`),
-        ...duplicateValueIssues(preset.features, `$.presets[${index}].features`),
-        ...duplicateValueIssues(preset.dependencyCatalog ?? [], `$.presets[${index}].dependencyCatalog`),
-    ]);
-}
-function fixtureCombinationKey(combination) {
-    return [
-        combination.basePreset,
-        combination.addedPreset,
-        ...(combination.linkFrom ?? []),
-    ].join("\0");
-}
-function fixtureCombinationPairKey(combination) {
-    return [combination.basePreset, combination.addedPreset].join("\0");
-}
-function fixtureMatrixContractIssues(manifest) {
-    if (!manifest.fixtureMatrix) {
-        return [];
-    }
-    const issues = [];
-    const presetsByName = new Map(manifest.presets.map((preset) => [preset.name, preset]));
-    const initPresets = new Set(manifest.fixtureMatrix.initSupport.map((support) => support.preset));
-    const addablePresets = new Set(manifest.fixtureMatrix.packageAdditionSupport.map((support) => support.preset));
-    const validInitPresets = new Set();
-    const validAddablePresets = new Set();
-    const supportedCombinationKeys = new Set();
-    const supportedCombinationPairKeys = new Set();
-    const semanticSkipKeys = new Set();
-    const semanticSkipPairKeys = new Set();
-    manifest.fixtureMatrix.initSupport.forEach((support, index) => {
-        const preset = presetsByName.get(support.preset);
-        if (!preset) {
-            issues.push({
-                path: `$.fixtureMatrix.initSupport[${index}].preset`,
-                message: `Fixture Matrix init support references unknown Preset: ${support.preset}`,
-            });
-            return;
-        }
-        if (preset.generation !== "supported") {
-            issues.push({
-                path: `$.fixtureMatrix.initSupport[${index}].preset`,
-                message: `Fixture Matrix init support must reference supported Presets: ${support.preset}`,
-            });
-            return;
-        }
-        validInitPresets.add(support.preset);
-    });
-    manifest.presets.forEach((preset, index) => {
-        if (preset.generation === "supported" &&
-            preset.packageAdditionSupport === PackageAdditionSupport.Supported &&
-            !addablePresets.has(preset.name)) {
-            issues.push({
-                path: `$.presets[${index}].packageAdditionSupport`,
-                message: `Fixture Matrix Package Addition support must declare supported Preset: ${preset.name}`,
-            });
-        }
-    });
-    manifest.fixtureMatrix.packageAdditionSupport.forEach((support, index) => {
-        const preset = presetsByName.get(support.preset);
-        if (!preset) {
-            issues.push({
-                path: `$.fixtureMatrix.packageAdditionSupport[${index}].preset`,
-                message: `Fixture Matrix Package Addition support references unknown Preset: ${support.preset}`,
-            });
-            return;
-        }
-        if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
-            issues.push({
-                path: `$.fixtureMatrix.packageAdditionSupport[${index}].preset`,
-                message: `Fixture Matrix Package Addition support must match Preset metadata: ${support.preset} is ${preset.packageAdditionSupport}`,
-            });
-            return;
-        }
-        validAddablePresets.add(support.preset);
-    });
-    manifest.fixtureMatrix.supportedCombinations.forEach((combination, index) => {
-        const key = fixtureCombinationKey(combination);
-        supportedCombinationPairKeys.add(fixtureCombinationPairKey(combination));
-        if (supportedCombinationKeys.has(key)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}]`,
-                message: `Duplicate Fixture Matrix supported combination: ${combination.basePreset} + ${combination.addedPreset}`,
-            });
-        }
-        supportedCombinationKeys.add(key);
-        if (!initPresets.has(combination.basePreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}].basePreset`,
-                message: `Fixture Matrix supported combination base Preset is not init-supported: ${combination.basePreset}`,
-            });
-        }
-        if (!addablePresets.has(combination.addedPreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}].addedPreset`,
-                message: `Fixture Matrix supported combination added Preset is not Package Addition-supported: ${combination.addedPreset}`,
-            });
-        }
-    });
-    manifest.fixtureMatrix.semanticSkips.forEach((skip, index) => {
-        const key = fixtureCombinationKey(skip);
-        semanticSkipPairKeys.add(fixtureCombinationPairKey(skip));
-        if (semanticSkipKeys.has(key)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}]`,
-                message: `Duplicate Fixture Matrix semantic skip: ${skip.basePreset} + ${skip.addedPreset}`,
-            });
-        }
-        semanticSkipKeys.add(key);
-        if (!initPresets.has(skip.basePreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}].basePreset`,
-                message: `Fixture Matrix semantic skip base Preset is not init-supported: ${skip.basePreset}`,
-            });
-        }
-        if (!presetsByName.has(skip.addedPreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}].addedPreset`,
-                message: `Fixture Matrix semantic skip references unknown added Preset: ${skip.addedPreset}`,
-            });
-        }
-    });
-    for (const basePreset of validInitPresets) {
-        for (const addedPreset of validAddablePresets) {
-            const key = fixtureCombinationPairKey({ basePreset, addedPreset });
-            if (!supportedCombinationPairKeys.has(key) &&
-                !semanticSkipPairKeys.has(key)) {
-                issues.push({
-                    path: "$.fixtureMatrix.supportedCombinations",
-                    message: `Fixture Matrix must explicitly cover supported combination or semantic skip: ${basePreset} + ${addedPreset}`,
-                });
-            }
-        }
-    }
-    for (const checkRequirement of requiredFixtureMatrixCheckRequirements) {
-        if (!manifest.fixtureMatrix.checkRequirements.includes(checkRequirement)) {
-            issues.push({
-                path: "$.fixtureMatrix.checkRequirements",
-                message: `Fixture Matrix check requirements must include ${checkRequirement}`,
-            });
-        }
-    }
-    for (const environmentPreparation of requiredFixtureMatrixEnvironmentPreparation) {
-        if (!manifest.fixtureMatrix.environmentPreparation.includes(environmentPreparation)) {
-            issues.push({
-                path: "$.fixtureMatrix.environmentPreparation",
-                message: `Fixture Matrix environment preparation must include ${environmentPreparation}`,
-            });
-        }
-    }
-    for (const key of semanticSkipPairKeys) {
-        if (supportedCombinationPairKeys.has(key)) {
-            issues.push({
-                path: "$.fixtureMatrix.semanticSkips",
-                message: "Fixture Matrix semantic skips must not duplicate supported combinations",
-            });
-        }
-    }
-    return [
-        ...duplicateValueIssues(manifest.fixtureMatrix.initSupport.map((support) => support.preset), "$.fixtureMatrix.initSupport.preset"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.packageAdditionSupport.map((support) => support.preset), "$.fixtureMatrix.packageAdditionSupport.preset"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.checkRequirements, "$.fixtureMatrix.checkRequirements"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.environmentPreparation, "$.fixtureMatrix.environmentPreparation"),
-        ...issues,
-    ];
-}
+export { presetSourceManifestJsonSchema };
 function dependencyCatalogReferenceIssues(presets, dependencyCatalog) {
-    return presets.flatMap((preset, presetIndex) => (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 unsupportedProjectShapeIssues(presets) {
-    return presets.flatMap((preset, index) => preset.supportedProjectKinds.includes("single-package")
-        ? [
-            {
-                path: `$.presets[${index}].supportedProjectKinds`,
-                message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
-            },
-        ]
-        : []);
+    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)) {
@@ -674,12 +41,13 @@ function sharedResourcePathIssues(manifest, sourceRoot) {
     if (sourceRoot === undefined) {
         return [];
     }
-    return manifest.sharedResources.flatMap((resource, index) => {
+    return manifest.sharedResources.flatMap((resource, fallbackResourceIndex) => {
+        const resourceIndex = resource.manifestIndex ?? fallbackResourceIndex;
         const resolvedPath = resolvePresetSourcePath(sourceRoot, resource.path);
         if (typeof resolvedPath !== "string") {
             return [
                 {
-                    path: `$.sharedResources[${index}].path`,
+                    path: `$.sharedResources[${resourceIndex}].path`,
                     message: resolvedPath.issue,
                 },
             ];
@@ -687,7 +55,7 @@ function sharedResourcePathIssues(manifest, sourceRoot) {
         if (!existsSync(resolvedPath)) {
             return [
                 {
-                    path: `$.sharedResources[${index}].path`,
+                    path: `$.sharedResources[${resourceIndex}].path`,
                     message: `Shared Resource ${resource.id} path does not exist: ${resource.path}`,
                 },
             ];
@@ -696,7 +64,7 @@ function sharedResourcePathIssues(manifest, sourceRoot) {
         if (realPathIssue) {
             return [
                 {
-                    path: `$.sharedResources[${index}].path`,
+                    path: `$.sharedResources[${resourceIndex}].path`,
                     message: realPathIssue,
                 },
             ];
@@ -739,9 +107,55 @@ function inlineDependencyCatalogSpecifierIssues(input) {
         }));
     });
 }
+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, presetIndex) => {
+    return manifest.presets.flatMap((preset, fallbackPresetIndex) => {
+        const presetIndex = preset.manifestIndex ?? fallbackPresetIndex;
         const source = preset.source;
         if (!source) {
             return [];
@@ -787,6 +201,13 @@ function presetSourceReferenceIssues(manifest, sourceRoot) {
         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
         ? [
@@ -797,91 +218,25 @@ function supportedProjectionDeclarationIssues(presets) {
         ]
         : []);
 }
-function normalizePresetSourceManifestOutput(manifest) {
-    return {
-        schemaVersion: manifest.schemaVersion,
-        name: manifest.name,
-        sharedResources: manifest.sharedResources.map((resource) => ({
-            ...resource,
-        })),
-        ...(manifest.fixtureMatrix
-            ? {
-                fixtureMatrix: {
-                    initSupport: manifest.fixtureMatrix.initSupport.map((support) => ({
-                        ...support,
-                    })),
-                    packageAdditionSupport: manifest.fixtureMatrix.packageAdditionSupport.map((support) => ({
-                        ...support,
-                    })),
-                    supportedCombinations: manifest.fixtureMatrix.supportedCombinations.map((combination) => ({
-                        basePreset: combination.basePreset,
-                        addedPreset: combination.addedPreset,
-                        linkFrom: [...combination.linkFrom],
-                    })),
-                    semanticSkips: manifest.fixtureMatrix.semanticSkips.map((skip) => ({
-                        ...skip,
-                    })),
-                    checkRequirements: [...manifest.fixtureMatrix.checkRequirements],
-                    environmentPreparation: [
-                        ...manifest.fixtureMatrix.environmentPreparation,
-                    ],
-                },
-            }
-            : {}),
-        presets: manifest.presets.map((preset) => ({
-            name: preset.name,
-            title: preset.title,
-            description: preset.description,
-            generation: preset.generation,
-            packageAdditionSupport: preset.packageAdditionSupport,
-            supportedPackageManagers: [...preset.supportedPackageManagers],
-            supportedProjectKinds: [...preset.supportedProjectKinds],
-            features: [...preset.features],
-            dependencyCatalog: [...preset.dependencyCatalog],
-            ...(preset.projection
-                ? {
-                    projection: normalizePresetProjectionDeclaration(preset.projection),
-                }
-                : {}),
-            ...(preset.source
-                ? {
-                    source: {
-                        roots: [...preset.source.roots],
-                        files: [...preset.source.files],
-                        sharedResources: [...preset.source.sharedResources],
-                    },
-                }
-                : {}),
-        })),
-    };
-}
 export function validatePresetSourceManifest(input, options = {}) {
     const inlineDependencyIssues = inlineDependencyCatalogSpecifierIssues(input);
     if (inlineDependencyIssues.length > 0) {
         return { ok: false, issues: inlineDependencyIssues };
     }
-    const result = v.safeParse(presetSourceManifestSchema, input);
-    if (!result.success) {
-        return { ok: false, issues: shapeIssues(result.issues) };
-    }
-    const parsedManifest = result.output;
-    const semanticIssues = [
-        ...duplicateValueIssues(parsedManifest.sharedResources.map((resource) => resource.id), "$.sharedResources.id"),
-        ...duplicatePresetNameIssues(parsedManifest.presets),
-        ...duplicatePresetMetadataArrayIssues(parsedManifest.presets),
-        ...unsupportedProjectShapeIssues(parsedManifest.presets),
-        ...fixtureMatrixContractIssues(parsedManifest),
-        ...dependencyCatalogReferenceIssues(parsedManifest.presets, options.dependencyCatalog ?? loadTemplateDependencyCatalog()),
-        ...projectionCapabilityIssues(parsedManifest.presets),
-        ...sharedResourcePathIssues(parsedManifest, options.sourceRoot),
-        ...presetSourceReferenceIssues(parsedManifest, options.sourceRoot),
-    ];
-    if (semanticIssues.length > 0) {
-        return { ok: false, issues: semanticIssues };
+    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: normalizePresetSourceManifestOutput(parsedManifest),
+        value: result.value,
     };
 }
 export function validateBuiltInPresetSourceManifest(input, options = {}) {