@ykdz/template 0.0.9 → 0.0.11

package/node_modules/@ykdz/template-shared/dist/index.js

@@ -0,0 +1,1637 @@
+import * as v from "valibot";
+export const PackageAdditionSupport = {
+    Supported: "supported",
+    Unsupported: "unsupported",
+};
+export const packageAdditionSupportValues = [
+    PackageAdditionSupport.Supported,
+    PackageAdditionSupport.Unsupported,
+];
+export const packageManagerValues = [
+    "pnpm",
+];
+export const presetGenerationValues = [
+    "supported",
+    "future",
+];
+export const projectKindValues = [
+    "single-package",
+    "multi-package",
+];
+export const projectKindJsonSchemaEnum = [
+    "multi-package",
+];
+export const featureNameValues = [
+    "pnpm-catalog",
+    "oxc-format-lint",
+    "strict-typescript",
+    "root-check",
+    "fix-command",
+    "devcontainer",
+    "github-actions",
+    "dependabot",
+    "rustfmt-clippy",
+    "cargo-test",
+    "native-binary-release",
+];
+export const packageManagerJsonSchemaEnum = packageManagerValues;
+export const presetGenerationJsonSchemaEnum = presetGenerationValues;
+export const featureNameJsonSchemaEnum = featureNameValues;
+export const projectionCapabilityKinds = [
+    "workspace-library-package",
+    "workspace-node-packages",
+    "rust-binary-workspace",
+    "strict-typescript-root",
+    "oxc-format-lint",
+    "node-pnpm-devcontainer",
+    "github-maintenance",
+];
+export const packageLeafNamePattern = "^[a-z0-9][a-z0-9-]*$";
+const packageLeafNameRegExp = new RegExp(packageLeafNamePattern);
+export const requiredFixtureMatrixCheckRequirements = [
+    "machine-verifiable-next-steps",
+    "root-check-ci",
+];
+export 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: presetGenerationJsonSchemaEnum },
+                    supportedPackageManagers: {
+                        type: "array",
+                        items: { enum: packageManagerJsonSchemaEnum },
+                        uniqueItems: true,
+                    },
+                    supportedProjectKinds: {
+                        type: "array",
+                        minItems: 1,
+                        items: { enum: projectKindJsonSchemaEnum },
+                        uniqueItems: true,
+                    },
+                    packageAdditionSupport: { enum: packageAdditionSupportValues },
+                    features: {
+                        type: "array",
+                        items: { enum: featureNameJsonSchemaEnum },
+                        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",
+                                                "devcontainerResourceId",
+                                                "editorCustomizationResourceId",
+                                            ],
+                                            properties: {
+                                                kind: { const: "rust-binary-workspace" },
+                                                workspacePackageGlob: { const: "packages/*" },
+                                                sourceFiles: {
+                                                    type: "array",
+                                                    minItems: 1,
+                                                    items: { type: "string", minLength: 1 },
+                                                },
+                                                devcontainerResourceId: {
+                                                    type: "string",
+                                                    minLength: 1,
+                                                },
+                                                editorCustomizationResourceId: {
+                                                    type: "string",
+                                                    minLength: 1,
+                                                },
+                                            },
+                                        },
+                                        {
+                                            type: "object",
+                                            additionalProperties: false,
+                                            required: ["kind"],
+                                            properties: { kind: { const: "strict-typescript-root" } },
+                                        },
+                                        {
+                                            type: "object",
+                                            additionalProperties: false,
+                                            required: ["kind", "editorCustomizationResourceId"],
+                                            properties: {
+                                                kind: { const: "oxc-format-lint" },
+                                                editorCustomizationResourceId: {
+                                                    type: "string",
+                                                    minLength: 1,
+                                                },
+                                            },
+                                        },
+                                        {
+                                            type: "object",
+                                            additionalProperties: false,
+                                            required: ["kind", "devcontainerResourceId"],
+                                            properties: {
+                                                kind: { const: "node-pnpm-devcontainer" },
+                                                devcontainerResourceId: {
+                                                    type: "string",
+                                                    minLength: 1,
+                                                },
+                                            },
+                                        },
+                                        {
+                                            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));
+export const presetGenerationSchema = v.picklist(presetGenerationValues);
+export const packageManagerSchema = v.picklist(packageManagerValues);
+export const projectKindSchema = v.picklist(projectKindValues);
+export const featureNameSchema = v.picklist(featureNameValues);
+const packageRoleSchema = v.picklist([
+    "runtime-service",
+    "shared-library",
+]);
+const packageSourcePresetSchema = v.picklist([
+    "hono-api",
+    "ts-lib",
+    "vue-app",
+]);
+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)),
+});
+export const presetProjectionDeclarationSchema = v.strictObject({
+    capabilities: v.array(v.looseObject({
+        kind: v.string(),
+    })),
+});
+export 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: presetGenerationSchema,
+        supportedPackageManagers: v.array(packageManagerSchema),
+        supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
+        packageAdditionSupport: v.picklist(packageAdditionSupportValues),
+        features: v.array(featureNameSchema),
+        dependencyCatalog: v.optional(v.array(nonEmptyString), []),
+        projection: v.optional(presetProjectionDeclarationSchema),
+        source: v.optional(presetSourceManifestPresetSourceSchema),
+    })), v.minLength(1)),
+});
+export const presetFileJsonSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://ykdz.dev/schemas/project-kit/preset-file.schema.json",
+    title: "Project Kit Preset File",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schemaVersion",
+        "name",
+        "title",
+        "description",
+        "supportedPackageManagers",
+        "supportedProjectKinds",
+        "features",
+    ],
+    properties: {
+        schemaVersion: { const: 1 },
+        name: { type: "string", minLength: 1 },
+        title: { type: "string", minLength: 1 },
+        description: { type: "string", minLength: 1 },
+        supportedPackageManagers: {
+            type: "array",
+            items: { enum: packageManagerJsonSchemaEnum },
+            uniqueItems: true,
+        },
+        supportedProjectKinds: {
+            type: "array",
+            minItems: 1,
+            items: { enum: projectKindJsonSchemaEnum },
+            uniqueItems: true,
+        },
+        features: {
+            type: "array",
+            items: { enum: featureNameJsonSchemaEnum },
+            uniqueItems: true,
+        },
+    },
+};
+export const blueprintJsonSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://ykdz.dev/schemas/project-kit/blueprint.schema.json",
+    title: "Project Kit Blueprint",
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "preset", "projectKind", "features"],
+    properties: {
+        schemaVersion: { const: 1 },
+        preset: { type: "string", minLength: 1 },
+        packageManager: { enum: packageManagerJsonSchemaEnum },
+        projectKind: { enum: projectKindJsonSchemaEnum },
+        features: {
+            type: "array",
+            items: { enum: featureNameJsonSchemaEnum },
+            uniqueItems: true,
+        },
+        packages: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["name", "path"],
+                properties: {
+                    name: { type: "string", minLength: 1 },
+                    path: { type: "string", minLength: 1 },
+                    role: { enum: ["runtime-service", "shared-library"] },
+                    sourcePreset: { enum: ["hono-api", "ts-lib", "vue-app"] },
+                },
+            },
+        },
+        packageLinkIntents: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["consumerPackagePath", "providerPackagePath"],
+                properties: {
+                    consumerPackagePath: { type: "string", minLength: 1 },
+                    providerPackagePath: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    },
+};
+export const presetFileSchema = v.strictObject({
+    schemaVersion: v.literal(1),
+    name: nonEmptyString,
+    title: nonEmptyString,
+    description: nonEmptyString,
+    supportedPackageManagers: v.array(packageManagerSchema),
+    supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
+    features: v.array(featureNameSchema),
+});
+export const projectBlueprintSchema = v.strictObject({
+    schemaVersion: v.literal(1),
+    preset: nonEmptyString,
+    packageManager: v.optional(packageManagerSchema),
+    projectKind: projectKindSchema,
+    features: v.array(featureNameSchema),
+    packages: v.optional(v.array(v.strictObject({
+        name: nonEmptyString,
+        path: nonEmptyString,
+        role: v.optional(packageRoleSchema),
+        sourcePreset: v.optional(packageSourcePresetSchema),
+    }))),
+    packageLinkIntents: v.optional(v.array(v.strictObject({
+        consumerPackagePath: nonEmptyString,
+        providerPackagePath: nonEmptyString,
+    }))),
+});
+function formatIssuePath(issue) {
+    if (!issue.path || issue.path.length === 0) {
+        return "$";
+    }
+    return issue.path.reduce((path, item) => `${path}.${String(item.key)}`, "$");
+}
+function shapeIssues(issues) {
+    return issues.map((issue) => ({
+        path: formatIssuePath(issue),
+        message: issue.message,
+    }));
+}
+function duplicateIssues(values, path) {
+    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,
+        message: `Duplicate value: ${value}`,
+    }));
+}
+function generationSupportIssue(preset, path) {
+    if (preset.generation === "supported") {
+        return undefined;
+    }
+    return {
+        path,
+        message: `Preset ${preset.name} is not supported for generation in this version`,
+    };
+}
+function unsupportedSinglePackageProjectShapeIssue(path) {
+    return {
+        path,
+        message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
+    };
+}
+function formatBracketIssuePath(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 presetSourceShapeIssues(issues) {
+    return issues.map((issue) => {
+        const validationPath = formatBracketIssuePath(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,
+    ];
+}
+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",
+            },
+        ]
+        : []);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyStringArray(value) {
+    const strings = [];
+    for (const entry of value) {
+        if (typeof entry !== "string" || entry.length === 0) {
+            return undefined;
+        }
+        strings.push(entry);
+    }
+    return strings.length === 0 ? undefined : strings;
+}
+const projectionCapabilityKindSet = new Set(projectionCapabilityKinds);
+const workspaceNodePackageKindSet = new Set(["hono-api", "vue-app"]);
+const workspaceNodePackagePathSet = new Set(["apps/api", "apps/web"]);
+function isProjectionCapabilityKind(value) {
+    return projectionCapabilityKindSet.has(value);
+}
+function isWorkspaceNodePackageKind(value) {
+    return typeof value === "string" && workspaceNodePackageKindSet.has(value);
+}
+function isWorkspaceNodePackagePath(value) {
+    return typeof value === "string" && workspaceNodePackagePathSet.has(value);
+}
+const exactCapabilityKeys = {
+    "workspace-library-package": [
+        "kind",
+        "workspacePackageGlob",
+        "packageRole",
+        "packageSourcePreset",
+        "sourceFiles",
+    ],
+    "workspace-node-packages": [
+        "kind",
+        "workspacePackageGlob",
+        "packages",
+        "packageLinks",
+    ],
+    "rust-binary-workspace": [
+        "kind",
+        "workspacePackageGlob",
+        "sourceFiles",
+        "devcontainerResourceId",
+        "editorCustomizationResourceId",
+    ],
+    "strict-typescript-root": ["kind"],
+    "oxc-format-lint": ["kind", "editorCustomizationResourceId"],
+    "node-pnpm-devcontainer": ["kind", "devcontainerResourceId"],
+    "github-maintenance": ["kind"],
+};
+const requiredPlanCapabilityProviders = [
+    { kind: "strict-typescript-root", label: "root check command" },
+    { kind: "oxc-format-lint", label: "fix command" },
+    { kind: "github-maintenance", label: "GitHub Actions maintenance" },
+    { kind: "github-maintenance", label: "Dependabot maintenance" },
+    { kind: "node-pnpm-devcontainer", label: "development container support" },
+];
+function unknownCapabilityPropertyIssues(kind, capability, pathPrefix) {
+    const allowedKeys = new Set(exactCapabilityKeys[kind]);
+    return Object.keys(capability)
+        .filter((key) => !allowedKeys.has(key))
+        .map((key) => ({
+        path: `${pathPrefix}.${key}`,
+        message: `Projection Capability ${kind} does not support property: ${key}`,
+    }));
+}
+function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
+    const issues = [];
+    let sourceFiles = [];
+    if (capability.workspacePackageGlob !== "packages/*") {
+        issues.push({
+            path: `${pathPrefix}.workspacePackageGlob`,
+            message: "workspace-library-package currently supports workspacePackageGlob: packages/*",
+        });
+    }
+    if (capability.packageRole !== "shared-library") {
+        issues.push({
+            path: `${pathPrefix}.packageRole`,
+            message: "workspace-library-package currently supports packageRole: shared-library",
+        });
+    }
+    if (capability.packageSourcePreset !== "ts-lib") {
+        issues.push({
+            path: `${pathPrefix}.packageSourcePreset`,
+            message: "workspace-library-package currently supports packageSourcePreset: ts-lib",
+        });
+    }
+    if (!Array.isArray(capability.sourceFiles)) {
+        issues.push({
+            path: `${pathPrefix}.sourceFiles`,
+            message: "workspace-library-package sourceFiles must be a non-empty array",
+        });
+    }
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(capability.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "workspace-library-package sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
+    }
+    if (issues.length > 0) {
+        return issues;
+    }
+    return {
+        kind: "workspace-library-package",
+        workspacePackageGlob: "packages/*",
+        packageRole: "shared-library",
+        packageSourcePreset: "ts-lib",
+        sourceFiles,
+    };
+}
+function parseWorkspaceNodePackage(value, pathPrefix) {
+    const issues = [];
+    if (!isRecord(value)) {
+        return [
+            {
+                path: pathPrefix,
+                message: "workspace-node-packages package must be an object",
+            },
+        ];
+    }
+    const kind = isWorkspaceNodePackageKind(value.kind) ? value.kind : undefined;
+    const packagePath = isWorkspaceNodePackagePath(value.path)
+        ? value.path
+        : undefined;
+    let sourceFiles = [];
+    if (kind === undefined) {
+        issues.push({
+            path: `${pathPrefix}.kind`,
+            message: "workspace-node-packages package kind must be hono-api or vue-app",
+        });
+    }
+    if (packagePath === undefined) {
+        issues.push({
+            path: `${pathPrefix}.path`,
+            message: "workspace-node-packages package path must be apps/api or apps/web",
+        });
+    }
+    if (!Array.isArray(value.sourceFiles)) {
+        issues.push({
+            path: `${pathPrefix}.sourceFiles`,
+            message: "workspace-node-packages package sourceFiles must be a non-empty array",
+        });
+    }
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(value.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "workspace-node-packages package sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
+    }
+    const allowedKeys = new Set(["kind", "path", "sourceFiles"]);
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.has(key)) {
+            issues.push({
+                path: `${pathPrefix}.${key}`,
+                message: `workspace-node-packages package does not support property: ${key}`,
+            });
+        }
+    }
+    if (issues.length > 0) {
+        return issues;
+    }
+    if (kind === undefined || packagePath === undefined) {
+        throw new Error(`workspace-node-packages package validation failed without diagnostics at ${pathPrefix}`);
+    }
+    return {
+        kind,
+        path: packagePath,
+        sourceFiles,
+    };
+}
+function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths, issues) {
+    if (!Array.isArray(value)) {
+        issues.push({
+            path: pathPrefix,
+            message: "workspace-node-packages packageLinks must be an array",
+        });
+        return undefined;
+    }
+    return value.flatMap((link, linkIndex) => {
+        const linkPath = `${pathPrefix}[${linkIndex}]`;
+        const linkIssues = [];
+        if (!isRecord(link)) {
+            issues.push({
+                path: linkPath,
+                message: "workspace-node-packages packageLink must be an object",
+            });
+            return [];
+        }
+        const allowedKeys = new Set(["consumerPackagePath", "providerPackagePath"]);
+        for (const key of Object.keys(link)) {
+            if (!allowedKeys.has(key)) {
+                linkIssues.push({
+                    path: `${linkPath}.${key}`,
+                    message: `workspace-node-packages packageLink does not support property: ${key}`,
+                });
+            }
+        }
+        if (link.consumerPackagePath !== "apps/web" ||
+            link.providerPackagePath !== "apps/api") {
+            linkIssues.push({
+                path: linkPath,
+                message: "workspace-node-packages currently supports links from apps/web to apps/api",
+            });
+        }
+        else {
+            if (!declaredPackagePaths.has(link.consumerPackagePath)) {
+                linkIssues.push({
+                    path: `${linkPath}.consumerPackagePath`,
+                    message: "workspace-node-packages packageLink consumerPackagePath must reference a package declared in the same packages array: apps/web",
+                });
+            }
+            if (!declaredPackagePaths.has(link.providerPackagePath)) {
+                linkIssues.push({
+                    path: `${linkPath}.providerPackagePath`,
+                    message: "workspace-node-packages packageLink providerPackagePath must reference a package declared in the same packages array: apps/api",
+                });
+            }
+        }
+        if (linkIssues.length > 0) {
+            issues.push(...linkIssues);
+            return [];
+        }
+        return [
+            {
+                consumerPackagePath: "apps/web",
+                providerPackagePath: "apps/api",
+            },
+        ];
+    });
+}
+function parseWorkspaceNodePackagesCapability(capability, pathPrefix) {
+    const issues = [];
+    if (capability.workspacePackageGlob !== "apps/*") {
+        issues.push({
+            path: `${pathPrefix}.workspacePackageGlob`,
+            message: "workspace-node-packages currently supports workspacePackageGlob: apps/*",
+        });
+    }
+    if (!Array.isArray(capability.packages) || capability.packages.length === 0) {
+        issues.push({
+            path: `${pathPrefix}.packages`,
+            message: "workspace-node-packages packages must be a non-empty array",
+        });
+    }
+    const packages = Array.isArray(capability.packages)
+        ? capability.packages.flatMap((nodePackage, packageIndex) => {
+            const packagePath = `${pathPrefix}.packages[${packageIndex}]`;
+            const parsed = parseWorkspaceNodePackage(nodePackage, packagePath);
+            if (Array.isArray(parsed)) {
+                issues.push(...parsed);
+                return [];
+            }
+            return [parsed];
+        })
+        : [];
+    const packageLinks = capability.packageLinks === undefined
+        ? undefined
+        : parseWorkspaceNodePackageLinks(capability.packageLinks, `${pathPrefix}.packageLinks`, new Set(packages.map((nodePackage) => nodePackage.path)), issues);
+    if (issues.length > 0) {
+        return issues;
+    }
+    return {
+        kind: "workspace-node-packages",
+        workspacePackageGlob: "apps/*",
+        packages,
+        ...(packageLinks === undefined ? {} : { packageLinks }),
+    };
+}
+function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
+    const issues = [];
+    let sourceFiles = [];
+    let devcontainerResourceId = "";
+    let editorCustomizationResourceId = "";
+    if (capability.workspacePackageGlob !== "packages/*") {
+        issues.push({
+            path: `${pathPrefix}.workspacePackageGlob`,
+            message: "rust-binary-workspace currently supports workspacePackageGlob: packages/*",
+        });
+    }
+    if (!Array.isArray(capability.sourceFiles)) {
+        issues.push({
+            path: `${pathPrefix}.sourceFiles`,
+            message: "rust-binary-workspace sourceFiles must be a non-empty array",
+        });
+    }
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(capability.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "rust-binary-workspace sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
+    }
+    if (typeof capability.devcontainerResourceId !== "string" ||
+        capability.devcontainerResourceId.length === 0) {
+        issues.push({
+            path: `${pathPrefix}.devcontainerResourceId`,
+            message: "rust-binary-workspace must declare a devcontainerResourceId Shared Resource id",
+        });
+    }
+    else {
+        devcontainerResourceId = capability.devcontainerResourceId;
+    }
+    if (typeof capability.editorCustomizationResourceId !== "string" ||
+        capability.editorCustomizationResourceId.length === 0) {
+        issues.push({
+            path: `${pathPrefix}.editorCustomizationResourceId`,
+            message: "rust-binary-workspace must declare an editorCustomizationResourceId Shared Resource id",
+        });
+    }
+    else {
+        editorCustomizationResourceId = capability.editorCustomizationResourceId;
+    }
+    if (issues.length > 0) {
+        return issues;
+    }
+    return {
+        kind: "rust-binary-workspace",
+        workspacePackageGlob: "packages/*",
+        sourceFiles,
+        devcontainerResourceId,
+        editorCustomizationResourceId,
+    };
+}
+function parseOxcFormatLintCapability(capability, pathPrefix) {
+    if (typeof capability.editorCustomizationResourceId !== "string" ||
+        capability.editorCustomizationResourceId.length === 0) {
+        return [
+            {
+                path: `${pathPrefix}.editorCustomizationResourceId`,
+                message: "oxc-format-lint must declare an editorCustomizationResourceId Shared Resource id",
+            },
+        ];
+    }
+    return {
+        kind: "oxc-format-lint",
+        editorCustomizationResourceId: capability.editorCustomizationResourceId,
+    };
+}
+function parseNodePnpmDevcontainerCapability(capability, pathPrefix) {
+    if (typeof capability.devcontainerResourceId !== "string" ||
+        capability.devcontainerResourceId.length === 0) {
+        return [
+            {
+                path: `${pathPrefix}.devcontainerResourceId`,
+                message: "node-pnpm-devcontainer must declare a devcontainerResourceId Shared Resource id",
+            },
+        ];
+    }
+    return {
+        kind: "node-pnpm-devcontainer",
+        devcontainerResourceId: capability.devcontainerResourceId,
+    };
+}
+function duplicateCapabilityIssues(capabilities) {
+    const firstSeen = new Map();
+    const issues = [];
+    capabilities.forEach((capability, index) => {
+        const firstIndex = firstSeen.get(capability.kind);
+        if (firstIndex === undefined) {
+            firstSeen.set(capability.kind, index);
+            return;
+        }
+        issues.push({
+            path: `$.capabilities[${index}].kind`,
+            message: `Duplicate Projection Capability kind: ${capability.kind}`,
+        });
+    });
+    return issues;
+}
+function uniqueValues(values) {
+    return [...new Set(values)];
+}
+function capabilityCompositionIssues(capabilities) {
+    const kinds = new Set(capabilities.map((capability) => capability.kind));
+    const issues = [];
+    const companionKinds = uniqueValues(capabilities
+        .map((capability) => capability.kind)
+        .filter((kind) => kind !== "rust-binary-workspace"));
+    if (kinds.has("rust-binary-workspace") && companionKinds.length > 0) {
+        issues.push({
+            path: "$.capabilities",
+            message: "rust-binary-workspace is a complete domain capability and must be selected by itself; remove companion Projection Capabilities: " +
+                companionKinds.join(", "),
+        });
+        return issues;
+    }
+    if (!kinds.has("workspace-library-package") &&
+        !kinds.has("workspace-node-packages") &&
+        !kinds.has("rust-binary-workspace")) {
+        issues.push({
+            path: "$.capabilities",
+            message: "Projection Capability composition must include a workspace package layout capability",
+        });
+    }
+    if (kinds.has("strict-typescript-root") &&
+        !kinds.has("workspace-library-package") &&
+        !kinds.has("workspace-node-packages")) {
+        issues.push({
+            path: "$.capabilities",
+            message: "strict-typescript-root requires a workspace package layout so package typecheck tasks have a workspace target",
+        });
+    }
+    if (kinds.has("node-pnpm-devcontainer") && !kinds.has("oxc-format-lint")) {
+        issues.push({
+            path: "$.capabilities",
+            message: "node-pnpm-devcontainer requires oxc-format-lint so editor customization is derived from declared tooling",
+        });
+    }
+    for (const requirement of requiredPlanCapabilityProviders) {
+        if (!kinds.has(requirement.kind) && !kinds.has("rust-binary-workspace")) {
+            issues.push({
+                path: "$.capabilities",
+                message: `Projection Capability composition must include ${requirement.kind} to provide ${requirement.label}`,
+            });
+        }
+    }
+    return issues;
+}
+export function validatePresetProjectionDeclaration(input) {
+    if (!isRecord(input) || !Array.isArray(input.capabilities)) {
+        return {
+            ok: false,
+            issues: [
+                {
+                    path: "$.capabilities",
+                    message: "Projection Declaration must select Projection Capabilities",
+                },
+            ],
+        };
+    }
+    const issues = [];
+    const capabilities = [];
+    input.capabilities.forEach((capability, index) => {
+        const pathPrefix = `$.capabilities[${index}]`;
+        if (!isRecord(capability)) {
+            issues.push({
+                path: pathPrefix,
+                message: "Projection Capability must be an object",
+            });
+            return;
+        }
+        if (typeof capability.kind !== "string") {
+            issues.push({
+                path: `${pathPrefix}.kind`,
+                message: "Projection Capability kind is required",
+            });
+            return;
+        }
+        if (!isProjectionCapabilityKind(capability.kind)) {
+            issues.push({
+                path: `${pathPrefix}.kind`,
+                message: `Unknown Projection Capability kind: ${capability.kind}`,
+            });
+            return;
+        }
+        const kind = capability.kind;
+        issues.push(...unknownCapabilityPropertyIssues(kind, capability, pathPrefix));
+        if (kind === "workspace-library-package") {
+            const workspaceCapability = parseWorkspaceLibraryPackageCapability(capability, pathPrefix);
+            if (Array.isArray(workspaceCapability)) {
+                issues.push(...workspaceCapability);
+                return;
+            }
+            capabilities.push(workspaceCapability);
+            return;
+        }
+        if (kind === "workspace-node-packages") {
+            const workspaceCapability = parseWorkspaceNodePackagesCapability(capability, pathPrefix);
+            if (Array.isArray(workspaceCapability)) {
+                issues.push(...workspaceCapability);
+                return;
+            }
+            capabilities.push(workspaceCapability);
+            return;
+        }
+        if (kind === "rust-binary-workspace") {
+            const workspaceCapability = parseRustBinaryWorkspaceCapability(capability, pathPrefix);
+            if (Array.isArray(workspaceCapability)) {
+                issues.push(...workspaceCapability);
+                return;
+            }
+            capabilities.push(workspaceCapability);
+            return;
+        }
+        if (kind === "oxc-format-lint") {
+            const oxcFormatLintCapability = parseOxcFormatLintCapability(capability, pathPrefix);
+            if (Array.isArray(oxcFormatLintCapability)) {
+                issues.push(...oxcFormatLintCapability);
+                return;
+            }
+            capabilities.push(oxcFormatLintCapability);
+            return;
+        }
+        if (kind === "node-pnpm-devcontainer") {
+            const nodePnpmDevcontainerCapability = parseNodePnpmDevcontainerCapability(capability, pathPrefix);
+            if (Array.isArray(nodePnpmDevcontainerCapability)) {
+                issues.push(...nodePnpmDevcontainerCapability);
+                return;
+            }
+            capabilities.push(nodePnpmDevcontainerCapability);
+            return;
+        }
+        capabilities.push({ kind });
+    });
+    if (issues.length === 0) {
+        issues.push(...duplicateCapabilityIssues(capabilities));
+        issues.push(...capabilityCompositionIssues(capabilities));
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return { ok: true, value: { capabilities } };
+}
+export function projectionCapabilityIssues(presets) {
+    return presets.flatMap((preset, presetIndex) => {
+        if (preset.projection === undefined) {
+            return [];
+        }
+        const result = validatePresetProjectionDeclaration(preset.projection);
+        return result.ok
+            ? []
+            : result.issues.map((issue) => ({
+                path: `$.presets[${presetIndex}].projection${issue.path.slice(1)}`,
+                message: issue.message,
+            }));
+    });
+}
+function projectionCapabilitySharedResourceIssues(manifest) {
+    const sharedResourceIds = new Set(manifest.sharedResources.map((resource) => resource.id));
+    const issues = [];
+    manifest.presets.forEach((preset, presetIndex) => {
+        if (preset.projection === undefined) {
+            return;
+        }
+        const result = validatePresetProjectionDeclaration(preset.projection);
+        if (!result.ok) {
+            return;
+        }
+        result.value.capabilities.forEach((capability, capabilityIndex) => {
+            if (capability.kind === "oxc-format-lint") {
+                const resourceId = capability.editorCustomizationResourceId;
+                if (!sharedResourceIds.has(resourceId)) {
+                    issues.push({
+                        path: `$.presets[${presetIndex}].projection.capabilities[${capabilityIndex}].editorCustomizationResourceId`,
+                        message: `Projection Capability oxc-format-lint references undeclared Shared Resource: ${resourceId}`,
+                    });
+                }
+            }
+            if (capability.kind === "node-pnpm-devcontainer") {
+                const resourceId = capability.devcontainerResourceId;
+                if (!sharedResourceIds.has(resourceId)) {
+                    issues.push({
+                        path: `$.presets[${presetIndex}].projection.capabilities[${capabilityIndex}].devcontainerResourceId`,
+                        message: `Projection Capability node-pnpm-devcontainer references undeclared Shared Resource: ${resourceId}`,
+                    });
+                }
+            }
+            if (capability.kind === "rust-binary-workspace") {
+                const devcontainerResourceId = capability.devcontainerResourceId;
+                if (!sharedResourceIds.has(devcontainerResourceId)) {
+                    issues.push({
+                        path: `$.presets[${presetIndex}].projection.capabilities[${capabilityIndex}].devcontainerResourceId`,
+                        message: `Projection Capability rust-binary-workspace references undeclared Shared Resource: ${devcontainerResourceId}`,
+                    });
+                }
+                const editorCustomizationResourceId = capability.editorCustomizationResourceId;
+                if (!sharedResourceIds.has(editorCustomizationResourceId)) {
+                    issues.push({
+                        path: `$.presets[${presetIndex}].projection.capabilities[${capabilityIndex}].editorCustomizationResourceId`,
+                        message: `Projection Capability rust-binary-workspace references undeclared Shared Resource: ${editorCustomizationResourceId}`,
+                    });
+                }
+            }
+        });
+    });
+    return issues;
+}
+export function normalizePresetProjectionDeclaration(declaration) {
+    const result = validatePresetProjectionDeclaration(declaration);
+    if (!result.ok) {
+        throw new Error(`Projection Declaration is invalid:\n${result.issues
+            .map((issue) => `  - ${issue.path}: ${issue.message}`)
+            .join("\n")}`);
+    }
+    return result.value;
+}
+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 validatePresetSourceManifestDeclaration(input) {
+    const result = v.safeParse(presetSourceManifestSchema, input);
+    if (!result.success) {
+        return { ok: false, issues: presetSourceShapeIssues(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),
+        ...projectionCapabilityIssues(parsedManifest.presets),
+        ...projectionCapabilitySharedResourceIssues(parsedManifest),
+    ];
+    if (semanticIssues.length > 0) {
+        return { ok: false, issues: semanticIssues };
+    }
+    return {
+        ok: true,
+        value: normalizePresetSourceManifestOutput(parsedManifest),
+    };
+}
+export function findPreset(presets, name) {
+    return presets.find((preset) => preset.name === name);
+}
+export function validatePresetFile(input, options = {}) {
+    const result = v.safeParse(presetFileSchema, input);
+    if (!result.success) {
+        return { ok: false, issues: shapeIssues(result.issues) };
+    }
+    const semanticIssues = [
+        ...duplicateIssues(result.output.supportedPackageManagers, "$.supportedPackageManagers"),
+        ...duplicateIssues(result.output.supportedProjectKinds, "$.supportedProjectKinds"),
+        ...duplicateIssues(result.output.features, "$.features"),
+    ];
+    if (result.output.supportedProjectKinds.includes("single-package")) {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.supportedProjectKinds"));
+    }
+    const catalogPreset = findPreset(options.presets ?? [], result.output.name);
+    const unsupportedGeneration = catalogPreset
+        ? generationSupportIssue(catalogPreset, "$.name")
+        : undefined;
+    if (unsupportedGeneration) {
+        semanticIssues.push(unsupportedGeneration);
+    }
+    if (semanticIssues.length > 0) {
+        return { ok: false, issues: semanticIssues };
+    }
+    return { ok: true, value: result.output };
+}
+function normalizeProjectBlueprint(blueprint) {
+    return {
+        schemaVersion: blueprint.schemaVersion,
+        preset: blueprint.preset,
+        ...(blueprint.packageManager === undefined
+            ? {}
+            : { packageManager: blueprint.packageManager }),
+        projectKind: blueprint.projectKind,
+        features: [...blueprint.features],
+        ...(blueprint.packages === undefined
+            ? {}
+            : {
+                packages: blueprint.packages.map((projectPackage) => ({
+                    name: projectPackage.name,
+                    path: projectPackage.path,
+                    ...(projectPackage.role === undefined
+                        ? {}
+                        : { role: projectPackage.role }),
+                    ...(projectPackage.sourcePreset === undefined
+                        ? {}
+                        : { sourcePreset: projectPackage.sourcePreset }),
+                })),
+            }),
+        ...(blueprint.packageLinkIntents === undefined
+            ? {}
+            : {
+                packageLinkIntents: blueprint.packageLinkIntents.map((intent) => ({
+                    consumerPackagePath: intent.consumerPackagePath,
+                    providerPackagePath: intent.providerPackagePath,
+                })),
+            }),
+    };
+}
+export function validateProjectBlueprint(input, options = {}) {
+    const result = v.safeParse(projectBlueprintSchema, input);
+    if (!result.success) {
+        return { ok: false, issues: shapeIssues(result.issues) };
+    }
+    const blueprint = normalizeProjectBlueprint(result.output);
+    const preset = findPreset(options.presets ?? [], blueprint.preset);
+    const semanticIssues = [
+        ...duplicateIssues(blueprint.features, "$.features"),
+    ];
+    if (blueprint.projectKind === "single-package") {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.projectKind"));
+    }
+    if (options.presets && !preset) {
+        semanticIssues.push({
+            path: "$.preset",
+            message: `Unknown ${options.presetLabel ?? "built-in"} preset: ${blueprint.preset}`,
+        });
+    }
+    else if (preset) {
+        const unsupportedGeneration = generationSupportIssue(preset, "$.preset");
+        if (unsupportedGeneration) {
+            semanticIssues.push(unsupportedGeneration);
+        }
+        if (blueprint.packageManager &&
+            !preset.supportedPackageManagers.includes(blueprint.packageManager)) {
+            semanticIssues.push({
+                path: "$.packageManager",
+                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`,
+            });
+        }
+        if (!blueprint.packageManager &&
+            preset.supportedPackageManagers.length > 0) {
+            semanticIssues.push({
+                path: "$.packageManager",
+                message: `packageManager is required by preset ${preset.name}`,
+            });
+        }
+        if (!preset.supportedProjectKinds.includes(blueprint.projectKind)) {
+            semanticIssues.push({
+                path: "$.projectKind",
+                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`,
+            });
+        }
+        const supportedFeatures = new Set(preset.features);
+        for (const feature of blueprint.features) {
+            if (!supportedFeatures.has(feature)) {
+                semanticIssues.push({
+                    path: "$.features",
+                    message: `${feature} is not supported by preset ${preset.name}`,
+                });
+            }
+        }
+    }
+    if (blueprint.packages) {
+        semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"));
+    }
+    if (semanticIssues.length > 0) {
+        return { ok: false, issues: semanticIssues };
+    }
+    return { ok: true, value: blueprint };
+}