@ykdz/template 0.0.10 → 0.0.11

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

@@ -1,22 +1,13 @@
+import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validatePresetProjectionDeclaration as validateProjectionCapabilities, } from "@ykdz/template-shared";
 import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderGeneratedPnpmWorkspaceYaml, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
-import { editorCustomizationForCapabilities, } from "./editor-customization.js";
-import { renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
+import { editorCustomizationForCapabilities, loadEditorCustomizationDeclarations, } from "./editor-customization.js";
+import { playwrightBrowserAssetsEnvironmentNeed, renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
 import { packageManifestExposureFields, planPackageLinks, } from "./package-linking.js";
-const projectionCapabilityKinds = [
-    "workspace-library-package",
-    "workspace-node-packages",
-    "rust-binary-workspace",
-    "strict-typescript-root",
-    "oxc-format-lint",
-    "node-pnpm-devcontainer",
-    "github-maintenance",
-];
-const projectionCapabilityKindSet = new Set(projectionCapabilityKinds);
-const workspaceNodePackageKindSet = new Set(["hono-api", "vue-app"]);
-const workspaceNodePackagePathSet = new Set(["apps/api", "apps/web"]);
+export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
 const strictTypescriptRootBoundary = {
     kind: "workspace-orchestration",
     path: ".",
@@ -52,26 +43,6 @@ const requiredPlanCapabilityProviders = [
         label: "development container support",
     },
 ];
-const exactCapabilityKeys = {
-    "workspace-library-package": [
-        "kind",
-        "workspacePackageGlob",
-        "packageRole",
-        "packageSourcePreset",
-        "sourceFiles",
-    ],
-    "workspace-node-packages": [
-        "kind",
-        "workspacePackageGlob",
-        "packages",
-        "packageLinks",
-    ],
-    "rust-binary-workspace": ["kind", "workspacePackageGlob", "sourceFiles"],
-    "strict-typescript-root": ["kind"],
-    "oxc-format-lint": ["kind"],
-    "node-pnpm-devcontainer": ["kind"],
-    "github-maintenance": ["kind"],
-};
 const dependencyMaintenanceEcosystems = ["npm", "github-actions", "docker"];
 function strictTypeScriptCompilerOptions(options) {
     return {
@@ -110,12 +81,12 @@ const capabilityInterpreters = {
             if (capability.packages.length > 1) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
             }
-            if (hasVuePackage(capability)) {
-                state.rootCheckEnvironmentNeeds.push({
-                    kind: "playwright-browser-assets",
+            const vuePackage = findVuePackage(capability);
+            if (vuePackage !== undefined) {
+                state.rootCheckEnvironmentNeeds.push(playwrightBrowserAssetsEnvironmentNeed({
                     browser: "chromium",
-                    owner: { kind: "package-boundary", path: "apps/web" },
-                });
+                    owner: { kind: "package-boundary", path: vuePackage.path },
+                }));
                 state.editorCustomizationCapabilities.push("vue", "tailwind");
             }
             state.editorCustomizationCapabilities.push("vitest");
@@ -126,8 +97,8 @@ const capabilityInterpreters = {
         contribute({ capability, state }) {
             state.rustWorkspace = capability;
             state.sourceRoot = templateSourceRootForPreset(state, "rust-bin");
-            state.sourceRoots.sharedDevcontainer =
-                state.projectionSourceRoots.sharedDevcontainer();
+            setDevelopmentContainerResource(state, capability.devcontainerResourceId, "rust-binary-workspace");
+            setEditorCustomizationResource(state, capability.editorCustomizationResourceId, "rust-binary-workspace");
             state.rootCheckComponents.push({
                 kind: "turbo-package-check",
                 owner: workspaceGlobBoundary(capability.workspacePackageGlob),
@@ -193,8 +164,9 @@ const capabilityInterpreters = {
     },
     "oxc-format-lint": {
         kind: "oxc-format-lint",
-        contribute({ state }) {
+        contribute({ capability, state }) {
             state.sourceRoots.sharedOxc = state.projectionSourceRoots.sharedOxc();
+            setEditorCustomizationResource(state, capability.editorCustomizationResourceId, "oxc-format-lint");
             state.rootCheckComponents.unshift({
                 kind: "oxc-format-check",
                 owner: strictTypescriptRootBoundary,
@@ -243,9 +215,8 @@ const capabilityInterpreters = {
     },
     "node-pnpm-devcontainer": {
         kind: "node-pnpm-devcontainer",
-        contribute({ state }) {
-            state.sourceRoots.sharedDevcontainer =
-                state.projectionSourceRoots.sharedDevcontainer();
+        contribute({ capability, state }) {
+            setDevelopmentContainerResource(state, capability.devcontainerResourceId, "node-pnpm-devcontainer");
             state.flags.devcontainer = true;
             state.operationFactories.push(nodePnpmDevcontainerOperations);
         },
@@ -306,111 +277,6 @@ function contributeProjectionCapability(capability, state) {
             return;
     }
 }
-export function validateProjectionCapabilities(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;
-        }
-        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 = validateProjectionCapabilities(preset.projection);
-        return result.ok
-            ? []
-            : result.issues.map((issue) => ({
-                path: `$.presets[${presetIndex}].projection${issue.path.slice(1)}`,
-                message: issue.message,
-            }));
-    });
-}
-export function normalizePresetProjectionDeclaration(declaration) {
-    const result = validateProjectionCapabilities(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;
-}
 export function interpretPresetProjectionDeclaration(options) {
     const validation = validateProjectionCapabilities(options.declaration);
     if (!validation.ok) {
@@ -559,354 +425,37 @@ function createProjectionCompositionState(sourceRoots) {
         flags: {},
     };
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-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);
-}
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
+function uniqueValues(values) {
+    return [...new Set(values)];
 }
-function nonEmptyStringArray(value) {
-    const strings = [];
-    for (const entry of value) {
-        if (!isNonEmptyString(entry)) {
-            return undefined;
-        }
-        strings.push(entry);
+function setDevelopmentContainerResource(state, resourceId, capabilityKind) {
+    const root = state.projectionSourceRoots.sharedResource(resourceId);
+    if (root === undefined) {
+        throw new Error(`Projection Capability ${capabilityKind} references unresolved Development Container Shared Resource: ${resourceId}`);
     }
-    return strings.length === 0 ? undefined : strings;
-}
-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}`,
-    }));
+    const sourceRootKey = developmentContainerResourceSourceRootKey(resourceId);
+    state.devcontainerResource = { id: resourceId, root, sourceRootKey };
+    state.sourceRoots[sourceRootKey] = root;
 }
-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;
+function setEditorCustomizationResource(state, resourceId, capabilityKind) {
+    const root = state.projectionSourceRoots.sharedResource(resourceId);
+    if (root === undefined) {
+        throw new Error(`Projection Capability ${capabilityKind} references unresolved Editor Customization Shared Resource: ${resourceId}`);
     }
-    return {
-        kind: "workspace-library-package",
-        workspacePackageGlob: "packages/*",
-        packageRole: "shared-library",
-        packageSourcePreset: "ts-lib",
-        sourceFiles,
+    state.editorCustomizationResource = {
+        id: resourceId,
+        root,
+        declarations: loadEditorCustomizationDeclarations(root),
     };
 }
-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 developmentContainerResourceSourceRootKey(resourceId) {
+    return `devcontainer:${resourceId}`;
 }
-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",
-        });
+function editorCustomizationDeclarationsForState(state) {
+    if (state.editorCustomizationResource === undefined) {
+        throw new Error("Projection Capability composition did not provide Editor Customization Shared Resource");
     }
-    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 parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
-    const issues = [];
-    let sourceFiles = [];
-    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 (issues.length > 0) {
-        return issues;
-    }
-    return {
-        kind: "rust-binary-workspace",
-        workspacePackageGlob: "packages/*",
-        sourceFiles,
-    };
-}
-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 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;
-}
-function uniqueValues(values) {
-    return [...new Set(values)];
+    return state.editorCustomizationResource.declarations;
 }
 function projectNameFromDir(targetDir) {
     return path.basename(path.resolve(targetDir));
@@ -1242,7 +791,10 @@ function workspaceGlobBoundary(workspacePackageGlob) {
     };
 }
 function hasVuePackage(capability) {
-    return capability.packages.some((nodePackage) => nodePackage.kind === "vue-app");
+    return findVuePackage(capability) !== undefined;
+}
+function findVuePackage(capability) {
+    return capability.packages.find((nodePackage) => nodePackage.kind === "vue-app");
 }
 function sourceRootPreset(capability) {
     if (capability.packages.length === 1) {
@@ -1629,7 +1181,8 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
     const rootManifest = rustRootPackageJson(context, packageScripts, state);
     const packageManifest = rustWorkspacePackageJson(context, workspacePackageScripts);
     const rustLayer = rustToolLayer();
-    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities);
+    const dockerfileFragments = readDevelopmentContainerDockerfileFragments(state, ["rust"]);
+    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities, editorCustomizationDeclarationsForState(state));
     const developmentContainer = dockerfileFirstRustPnpmDevcontainer({
         name: context.projectName.value,
         nodeLayer: nodePnpmToolLayer({
@@ -1637,6 +1190,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
             packageManagerPin: context.toolchain.packageManagerPin.value,
         }),
         rustLayer,
+        dockerfileFragments,
         extensions: editorCustomization.extensions,
         settings: editorCustomization.settings,
     });
@@ -2168,7 +1722,7 @@ function rootTsconfigReferences(workspace) {
     });
 }
 function oxcFormatLintOperations({ state, }) {
-    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities);
+    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities, editorCustomizationDeclarationsForState(state));
     return [
         {
             kind: "copyFile",
@@ -2200,16 +1754,19 @@ function oxcFormatLintOperations({ state, }) {
     ];
 }
 function nodePnpmDevcontainerOperations({ context, state, }) {
-    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities);
+    const additionalLayers = state.nodeWorkspace && hasVuePackage(state.nodeWorkspace)
+        ? [browserTestToolLayer()]
+        : [];
+    const dockerfileFragments = readDevelopmentContainerDockerfileFragments(state, additionalLayers.length === 0 ? [] : ["browserTest"]);
+    const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities, editorCustomizationDeclarationsForState(state));
     const developmentContainer = checkedDockerfileFirstNodePnpmDevcontainer({
         name: context.projectName.value,
         layer: nodePnpmToolLayer({
             nodeVersion: context.toolchain.nodeLtsMajor.value,
             packageManagerPin: context.toolchain.packageManagerPin.value,
         }),
-        additionalLayers: state.nodeWorkspace && hasVuePackage(state.nodeWorkspace)
-            ? [browserTestToolLayer()]
-            : [],
+        dockerfileFragments,
+        additionalLayers,
         extensions: editorCustomization.extensions,
         settings: editorCustomization.settings,
     });
@@ -2224,6 +1781,51 @@ function nodePnpmDevcontainerOperations({ context, state, }) {
         },
     ];
 }
+function readDevelopmentContainerDockerfileFragments(state, optionalFragments) {
+    if (state.devcontainerResource === undefined) {
+        throw new Error("Projection Capability composition did not provide a Development Container Shared Resource");
+    }
+    const fragmentNames = {
+        nodePnpm: "node-pnpm.Dockerfile",
+        browserTest: "browser-test.Dockerfile",
+        rust: "rust.Dockerfile",
+    };
+    const selected = new Set(optionalFragments);
+    return {
+        sourceRoot: state.devcontainerResource.sourceRootKey,
+        nodePnpm: readDevelopmentContainerDockerfileFragment(state.devcontainerResource, fragmentNames.nodePnpm),
+        ...(selected.has("browserTest")
+            ? {
+                browserTest: readDevelopmentContainerDockerfileFragment(state.devcontainerResource, fragmentNames.browserTest),
+            }
+            : {}),
+        ...(selected.has("rust")
+            ? {
+                rust: readDevelopmentContainerDockerfileFragment(state.devcontainerResource, fragmentNames.rust),
+            }
+            : {}),
+    };
+}
+function readDevelopmentContainerDockerfileFragment(resource, fragmentName) {
+    const filePath = path.join(resource.root, fragmentName);
+    try {
+        return {
+            from: fragmentName,
+            text: readFileSync(filePath, "utf8"),
+        };
+    }
+    catch (error) {
+        if (isMissingDevelopmentContainerFragmentError(error)) {
+            throw new Error(`Development Container Shared Resource ${resource.id} is missing Dockerfile fragment: ${fragmentName}`, { cause: error });
+        }
+        throw error;
+    }
+}
+function isMissingDevelopmentContainerFragmentError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
 function githubMaintenanceOperations() {
     return [
         {