@ykdz/template 0.0.30 → 0.0.32

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

@@ -248,6 +248,21 @@ function memberIdentity(member, policy) {
         return scalarIdentity(member);
     if (!isStructuredObject(member))
         return undefined;
+    if (policy.identity.kind === "projection") {
+        const matches = policy.identity.members.filter(({ match }) => Object.entries(match).every(([field, value]) => Object.hasOwn(member, field) &&
+            structuredValuesEqual(member[field], value)));
+        const matchingIdentities = new Set(matches.map(({ identity }) => identity));
+        if (matchingIdentities.size > 1)
+            return undefined;
+        const [matchingIdentity] = matchingIdentities;
+        if (matchingIdentity !== undefined) {
+            return `projection:${JSON.stringify(matchingIdentity)}`;
+        }
+        const fallbackFields = policy.identity.fallback.fields.map((field) => Object.hasOwn(member, field) ? scalarIdentity(member[field]) : undefined);
+        return fallbackFields.every((field) => field !== undefined)
+            ? `fallback:${JSON.stringify(fallbackFields)}`
+            : undefined;
+    }
     const fields = policy.identity.fields.map((field) => Object.hasOwn(member, field) ? scalarIdentity(member[field]) : undefined);
     return fields.every((field) => field !== undefined)
         ? JSON.stringify(fields)
@@ -472,8 +487,52 @@ function assertProjectionContract(projection) {
     }
     return policies;
 }
-function reconciliationPoliciesEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+function reconciliationPoliciesCompatible(left, right) {
+    if (left.path !== right.path ||
+        left.driver !== right.driver ||
+        left.driver !== "structured" ||
+        right.driver !== "structured") {
+        return JSON.stringify(left) === JSON.stringify(right);
+    }
+    const leftIdentitySets = left.identitySets ?? [];
+    const rightIdentitySets = right.identitySets ?? [];
+    if (leftIdentitySets.length !== rightIdentitySets.length)
+        return false;
+    return leftIdentitySets.every((leftPolicy, index) => {
+        const rightPolicy = rightIdentitySets[index];
+        if (rightPolicy === undefined ||
+            leftPolicy.location !== rightPolicy.location ||
+            leftPolicy.identity.kind !== rightPolicy.identity.kind) {
+            return false;
+        }
+        if (leftPolicy.identity.kind !== "projection" ||
+            rightPolicy.identity.kind !== "projection") {
+            return JSON.stringify(leftPolicy) === JSON.stringify(rightPolicy);
+        }
+        return (JSON.stringify(leftPolicy.identity.fallback) ===
+            JSON.stringify(rightPolicy.identity.fallback));
+    });
+}
+function combinedIdentitySets(before, after) {
+    const beforeIdentitySets = before?.driver === "structured" ? (before.identitySets ?? []) : [];
+    const afterIdentitySets = after?.driver === "structured" ? (after.identitySets ?? []) : [];
+    return afterIdentitySets.map((afterPolicy, index) => {
+        const beforePolicy = beforeIdentitySets[index];
+        if (beforePolicy?.identity.kind !== "projection" ||
+            afterPolicy.identity.kind !== "projection") {
+            return afterPolicy;
+        }
+        return {
+            ...afterPolicy,
+            identity: {
+                ...afterPolicy.identity,
+                members: [
+                    ...beforePolicy.identity.members,
+                    ...afterPolicy.identity.members,
+                ],
+            },
+        };
+    });
 }
 function structuredValueAtLocation(root, pathSegments) {
     let value = root;
@@ -521,6 +580,24 @@ function assertIdentitySetPolicies(entry, reconciliation) {
                 policy.identity.fields.some((field) => field.length === 0))) {
             throw new Error(`Project Projection identity-set fields must be unique non-empty names: ${entry.path} ${location}`);
         }
+        if (policy.identity.kind === "projection") {
+            const fallbackFields = policy.identity.fallback.fields;
+            if (fallbackFields.length === 0 ||
+                new Set(fallbackFields).size !== fallbackFields.length ||
+                fallbackFields.some((field) => field.length === 0)) {
+                throw new Error(`Project Projection identity-set projection fallback fields must be unique non-empty names: ${entry.path} ${location}`);
+            }
+            const memberIdentities = policy.identity.members.map((member) => member.identity);
+            if (memberIdentities.some((identity) => identity.length === 0) ||
+                new Set(memberIdentities).size !== memberIdentities.length ||
+                policy.identity.members.some((member) => Object.keys(member.match).length === 0 ||
+                    Object.values(member.match).some((value) => value !== null &&
+                        typeof value !== "string" &&
+                        typeof value !== "number" &&
+                        typeof value !== "boolean"))) {
+                throw new Error(`Project Projection identity-set projection members require unique non-empty identities and non-empty scalar matches: ${entry.path} ${location}`);
+            }
+        }
         const value = structuredValueAtLocation(parsed.value, pathSegments);
         if (!Array.isArray(value)) {
             throw new Error(`Project Projection identity-set location must reference an array: ${entry.path} ${location}`);
@@ -547,7 +624,7 @@ export async function reconcileProjectProjections(options) {
         }
         if (afterPolicy !== undefined &&
             beforePolicy !== undefined &&
-            !reconciliationPoliciesEqual(beforePolicy, afterPolicy)) {
+            !reconciliationPoliciesCompatible(beforePolicy, afterPolicy)) {
             throw new Error(`Project Projection reconciliation policy changed for ${projectionPath}`);
         }
     }
@@ -561,7 +638,9 @@ export async function reconcileProjectProjections(options) {
     for (const projectionPath of deltaPaths) {
         const before = beforeByPath.get(projectionPath);
         const after = afterByPath.get(projectionPath);
-        const policy = afterPolicies.get(projectionPath) ?? beforePolicies.get(projectionPath);
+        const beforePolicy = beforePolicies.get(projectionPath);
+        const afterPolicy = afterPolicies.get(projectionPath);
+        const policy = afterPolicy ?? beforePolicy;
         const driver = policy.driver;
         const current = await options.readCurrent(projectionPath);
         if (entriesEqual(current, after))
@@ -622,7 +701,7 @@ export async function reconcileProjectProjections(options) {
                 before,
                 current,
                 after,
-                identitySets: policy.identitySets ?? [],
+                identitySets: combinedIdentitySets(beforePolicy, afterPolicy),
             })
             : undefined;
         const text = driver === "text"

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

@@ -66,6 +66,7 @@ export type WriteTextFromFragmentsOperation = {
         from: string;
         source: TemplateSourceHandle;
     }[];
+    validation?: "development-container-dockerfile" | undefined;
     overwrite?: boolean;
     provenance?: RenderOperationProvenance;
 };

package/node_modules/@ykdz/template-core/dist/renderer.js

@@ -176,16 +176,55 @@ async function renderWriteText(operation, options) {
     await mkdir(path.dirname(to), { recursive: true });
     await writeGeneratedFile(to, operation.text);
 }
-async function renderWriteTextFromFragments(operation, options) {
-    const toPath = expandOperationPath(operation.to, options);
-    const to = resolveContainedPath(options.targetRoot, toPath);
-    const texts = await Promise.all(operation.fragments.map(async (fragment) => {
+async function loadTextFragments(operation, options) {
+    return Promise.all(operation.fragments.map(async (fragment) => {
         const fromPath = expandTemplatePath(fragment.from, options.variables ?? {});
         const from = resolveTemplateSource(fragment.source, fromPath);
-        return readFile(from, "utf8");
+        return { from: fromPath, text: await readFile(from, "utf8") };
     }));
+}
+async function validateDevelopmentContainerDockerfileOperation(operation, fragments) {
+    if (operation.validation !== "development-container-dockerfile") {
+        return;
+    }
+    const [baseFragment, ...optionalFragments] = fragments;
+    if (baseFragment === undefined) {
+        throw new Error("Development Container Dockerfile requires a base fragment.");
+    }
+    const { validateDevelopmentContainerDockerfileFragments } = await import("./development-container-tool-layer.js");
+    validateDevelopmentContainerDockerfileFragments({
+        baseFragment: {
+            identity: baseFragment.from,
+            from: baseFragment.from,
+            text: baseFragment.text,
+        },
+        fragments: optionalFragments.map((fragment) => ({
+            identity: fragment.from,
+            from: fragment.from,
+            text: fragment.text,
+        })),
+    });
+}
+async function preflightDevelopmentContainerDockerfiles(options) {
+    const loadedFragments = new Map();
+    for (const operation of options.operations) {
+        if (operation.kind !== "writeTextFromFragments" ||
+            operation.validation !== "development-container-dockerfile") {
+            continue;
+        }
+        const fragments = await loadTextFragments(operation, options);
+        await validateDevelopmentContainerDockerfileOperation(operation, fragments);
+        loadedFragments.set(operation, fragments);
+    }
+    return loadedFragments;
+}
+async function renderWriteTextFromFragments(operation, options, preloadedFragments) {
+    const toPath = expandOperationPath(operation.to, options);
+    const to = resolveContainedPath(options.targetRoot, toPath);
+    const fragments = preloadedFragments ?? (await loadTextFragments(operation, options));
+    await validateDevelopmentContainerDockerfileOperation(operation, fragments);
     await mkdir(path.dirname(to), { recursive: true });
-    await writeGeneratedFile(to, texts.map((text) => text.trimEnd()).join("\n\n") + "\n", operation.overwrite ?? false);
+    await writeGeneratedFile(to, fragments.map(({ text }) => text.trimEnd()).join("\n\n") + "\n", operation.overwrite ?? false);
 }
 function replaceTextTemplateVariables(sourceText, replacements) {
     const used = new Set();
@@ -341,6 +380,7 @@ async function writeGeneratedFile(to, text, overwrite = false) {
     }
 }
 export async function renderProject(options) {
+    const preloadedDevelopmentContainerDockerfiles = await preflightDevelopmentContainerDockerfiles(options);
     for (const operation of options.operations) {
         if (operation.kind === "copyFile") {
             await renderCopyFile(operation, options);
@@ -363,7 +403,7 @@ export async function renderProject(options) {
             continue;
         }
         if (operation.kind === "writeTextFromFragments") {
-            await renderWriteTextFromFragments(operation, options);
+            await renderWriteTextFromFragments(operation, options, preloadedDevelopmentContainerDockerfiles.get(operation));
             continue;
         }
         if (operation.kind === "writeTextTemplate") {

package/node_modules/@ykdz/template-core/dist/template-boundary-check.js

@@ -479,7 +479,28 @@ function isStructuralTsconfigConfigValue(value) {
 function isDevelopmentContainerPlanValue(expression) {
     return isPropertyAccess(expression, "developmentContainer", "devcontainer");
 }
+function isDevelopmentContainerToolLayerMergeValue(value) {
+    if (!isRecord(value) ||
+        !(hasExactKeys(value, ["build"]) || hasExactKeys(value, ["build", "mounts"])) ||
+        !isRecord(value.build) ||
+        !hasExactKeys(value.build, ["args"]) ||
+        !isRecord(value.build.args) ||
+        !Object.values(value.build.args).every((argument) => typeof argument === "string")) {
+        return false;
+    }
+    return (value.mounts === undefined ||
+        (Array.isArray(value.mounts) &&
+            value.mounts.every((mount) => isRecord(mount) &&
+                hasExactKeys(mount, ["type", "source", "target"]) &&
+                (mount.type === "bind" || mount.type === "volume") &&
+                typeof mount.source === "string" &&
+                typeof mount.target === "string")));
+}
 function isAllowedStructuralMachineDeclaration(sourceFile, operation) {
+    if (operation.kind === "mergeJson" &&
+        operation.to === ".devcontainer/devcontainer.json") {
+        return isDevelopmentContainerToolLayerMergeValue(operation.value);
+    }
     if (operation.kind !== "writeJson") {
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ykdz/template",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "private": false,
   "description": "Project template generator for YKDZ starter projects.",
   "keywords": [
@@ -60,8 +60,8 @@
     "semver": "^7.8.5",
     "typescript": "npm:typescript@^6.0.3",
     "valibot": "^1.4.2",
-    "@ykdz/template-builtin-presets": "0.0.0",
-    "@ykdz/template-core": "0.0.0"
+    "@ykdz/template-core": "0.0.0",
+    "@ykdz/template-builtin-presets": "0.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",
@@ -70,7 +70,7 @@
     "execa": "^10.0.0",
     "oxfmt": "^0.58.0",
     "oxlint": "^1.73.0",
-    "oxlint-tsgolint": "^0.24.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "typescript-7": "npm:typescript@^7.0.2",
     "vitest": "^4.1.10"
   },

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/rust/.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-  "recommendations": ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/rust/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-  "[rust]": {
-    "editor.defaultFormatter": "rust-lang.rust-analyzer"
-  }
-}

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/rust/devcontainer/devcontainer.json

@@ -1,21 +0,0 @@
-{
-  "name": "{{PROJECT_NAME}}",
-  "build": {
-    "dockerfile": "Dockerfile",
-    "args": {
-      "NODE_VERSION": "{{NODE_LTS_MAJOR}}",
-      "PACKAGE_MANAGER_PIN": "{{PACKAGE_MANAGER_PIN}}",
-      "RUST_TOOLCHAIN": "{{RUST_TOOLCHAIN}}"
-    }
-  },
-  "customizations": {
-    "vscode": {
-      "extensions": ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
-    }
-  },
-  "mounts": [
-    "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
-    "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
-    "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume"
-  ]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/rust/devcontainer/rust.Dockerfile

@@ -1,18 +0,0 @@
-ARG RUST_TOOLCHAIN
-ENV RUSTUP_HOME=/usr/local/rustup
-ENV CARGO_HOME=/usr/local/cargo
-ENV PATH="/usr/local/cargo/bin:${PATH}"
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    ca-certificates \
-    curl \
-    gcc \
-    git \
-    libc6-dev \
-    && rm -rf /var/lib/apt/lists/* \
-    && git config --system init.defaultBranch main
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
-    sh -s -- -y --profile minimal --default-toolchain none \
-    && rustup toolchain install ${RUST_TOOLCHAIN} --profile minimal --component rustfmt --component clippy \
-    && rustup default ${RUST_TOOLCHAIN} \
-    && chmod -R a+w ${RUSTUP_HOME} ${CARGO_HOME}

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/rust/rust-toolchain.toml

@@ -1,3 +0,0 @@
-[toolchain]
-channel = "{{RUST_TOOLCHAIN}}"
-components = ["rustfmt", "clippy"]

package/node_modules/@ykdz/template-builtin-presets/templates/rust-bin/devcontainer/devcontainer.json

@@ -1,21 +0,0 @@
-{
-  "name": "{{PROJECT_NAME}}",
-  "build": {
-    "dockerfile": "Dockerfile",
-    "args": {
-      "NODE_VERSION": "{{NODE_LTS_MAJOR}}",
-      "PACKAGE_MANAGER_PIN": "{{PACKAGE_MANAGER_PIN}}",
-      "RUST_TOOLCHAIN": "{{RUST_TOOLCHAIN}}"
-    }
-  },
-  "customizations": {
-    "vscode": {
-      "extensions": ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
-    }
-  },
-  "mounts": [
-    "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
-    "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
-    "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume"
-  ]
-}

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

@@ -1,83 +0,0 @@
-import type { TemplateSourceHandle, WriteTextFromFragmentsOperation } from "./renderer.ts";
-export type DevelopmentContainerNodePnpmLayer = {
-    readonly kind: "node-pnpm";
-    readonly nodeVersion: string;
-    readonly packageManagerPin: string;
-};
-export type DevelopmentContainerBrowserTestLayer = {
-    readonly kind: "browser-test";
-    readonly playwrightCliPackage: string;
-};
-export type DevelopmentContainerRustLayer = {
-    readonly kind: "rust";
-    readonly toolchain: string;
-};
-export type DevelopmentContainerShellCheckLayer = {
-    readonly kind: "shellcheck";
-};
-type DevelopmentContainerCapabilityLayer = DevelopmentContainerBrowserTestLayer | DevelopmentContainerShellCheckLayer | DevelopmentContainerRustLayer;
-export type DevelopmentContainerDockerfileFragments = {
-    readonly source: TemplateSourceHandle;
-    readonly nodePnpm: {
-        readonly from: string;
-        readonly text: string;
-    };
-    readonly browserTest?: {
-        readonly from: string;
-        readonly text: string;
-    } | undefined;
-    readonly shellCheck?: {
-        readonly from: string;
-        readonly text: string;
-    } | undefined;
-    readonly rust?: {
-        readonly from: string;
-        readonly text: string;
-    } | undefined;
-};
-export type DevelopmentContainerPlan = {
-    readonly devcontainer: Record<string, unknown>;
-    readonly dockerfile: string;
-    readonly dockerfileOperation?: WriteTextFromFragmentsOperation;
-};
-export type DevelopmentContainerDockerfileLayer = {
-    readonly kind: "base" | "capability";
-    readonly name: string;
-    readonly text: string;
-};
-export declare function composeDevelopmentContainerDockerfile(options: {
-    readonly layers: readonly DevelopmentContainerDockerfileLayer[];
-}): string;
-export declare function nodePnpmToolLayer(options: {
-    readonly nodeVersion: string;
-    readonly packageManagerPin: string;
-}): DevelopmentContainerNodePnpmLayer;
-export declare function browserTestToolLayer(): DevelopmentContainerBrowserTestLayer;
-export declare function shellCheckToolLayer(): DevelopmentContainerShellCheckLayer;
-export declare function rustToolLayer(options?: {
-    readonly toolchain?: string;
-}): DevelopmentContainerRustLayer;
-export declare function dockerfileFirstNodePnpmDevcontainer(options: {
-    readonly name: string;
-    readonly layer: DevelopmentContainerNodePnpmLayer;
-    readonly extensions: readonly string[];
-    readonly settings?: Record<string, unknown> | undefined;
-}): DevelopmentContainerPlan;
-export declare function checkedDockerfileFirstNodePnpmDevcontainer(options: {
-    readonly name: string;
-    readonly layer: DevelopmentContainerNodePnpmLayer;
-    readonly dockerfileFragments: DevelopmentContainerDockerfileFragments;
-    readonly additionalLayers?: readonly DevelopmentContainerCapabilityLayer[] | undefined;
-    readonly extensions: readonly string[];
-    readonly settings?: Record<string, unknown> | undefined;
-    readonly mounts?: readonly string[] | undefined;
-}): DevelopmentContainerPlan;
-export declare function dockerfileFirstRustPnpmDevcontainer(options: {
-    readonly name: string;
-    readonly nodeLayer: DevelopmentContainerNodePnpmLayer;
-    readonly rustLayer: DevelopmentContainerRustLayer;
-    readonly dockerfileFragments: DevelopmentContainerDockerfileFragments;
-    readonly extensions: readonly string[];
-    readonly settings?: Record<string, unknown> | undefined;
-}): DevelopmentContainerPlan;
-export {};

package/node_modules/@ykdz/template-core/dist/devcontainer.js

@@ -1,217 +0,0 @@
-import { loadTemplateDependencyCatalog } from "./dependency-catalog.js";
-function requireDockerfileFragment(fragments, name) {
-    const fragment = fragments[name];
-    if (fragment === undefined) {
-        throw new Error(`Development Container Dockerfile fragment is missing: ${name}`);
-    }
-    return fragment;
-}
-const runtimeDockerfileInstructions = new Set([
-    "CMD",
-    "ENTRYPOINT",
-    "EXPOSE",
-    "HEALTHCHECK",
-    "STOPSIGNAL",
-    "VOLUME",
-]);
-function dockerfileInstructions(text) {
-    return text
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && !line.startsWith("#"))
-        .map((line) => line.match(/^([A-Za-z]+)/)?.[1]?.toUpperCase())
-        .filter((instruction) => instruction !== undefined);
-}
-export function composeDevelopmentContainerDockerfile(options) {
-    const baseImageInstructionCount = options.layers.reduce((count, layer) => count +
-        dockerfileInstructions(layer.text).filter((instruction) => instruction === "FROM").length, 0);
-    if (baseImageInstructionCount !== 1) {
-        throw new Error(`Development Container Dockerfile must have exactly one base layer with a FROM instruction; found ${baseImageInstructionCount}.`);
-    }
-    for (const layer of options.layers) {
-        const instructions = dockerfileInstructions(layer.text);
-        if (layer.kind === "capability" && instructions.includes("FROM")) {
-            throw new Error(`${layer.name} capability layer must not supply a Dockerfile FROM instruction.`);
-        }
-        if (layer.kind !== "capability") {
-            continue;
-        }
-        for (const instruction of instructions) {
-            if (runtimeDockerfileInstructions.has(instruction)) {
-                throw new Error(`${layer.name} must not use runtime Dockerfile instruction ${instruction}.`);
-            }
-        }
-    }
-    return options.layers.map((layer) => layer.text.trimEnd()).join("\n\n");
-}
-export function nodePnpmToolLayer(options) {
-    return {
-        kind: "node-pnpm",
-        nodeVersion: options.nodeVersion,
-        packageManagerPin: options.packageManagerPin,
-    };
-}
-export function browserTestToolLayer() {
-    const playwrightTestVersion = loadTemplateDependencyCatalog()["@playwright/test"];
-    if (playwrightTestVersion === undefined) {
-        throw new Error("Template Dependency Catalog is missing dependency: @playwright/test");
-    }
-    return {
-        kind: "browser-test",
-        playwrightCliPackage: `@playwright/test@${playwrightTestVersion}`,
-    };
-}
-export function shellCheckToolLayer() {
-    return { kind: "shellcheck" };
-}
-export function rustToolLayer(options = {}) {
-    return { kind: "rust", toolchain: options.toolchain ?? "stable" };
-}
-function checkedNodePnpmDockerfile(options) {
-    return composeDevelopmentContainerDockerfile({
-        layers: [
-            {
-                kind: "base",
-                name: "node-pnpm",
-                text: options.dockerfileFragments.nodePnpm.text,
-            },
-            ...(options.additionalLayers ?? []).map((layer) => {
-                switch (layer.kind) {
-                    case "browser-test":
-                        return {
-                            kind: "capability",
-                            name: "browser-test",
-                            text: requireDockerfileFragment(options.dockerfileFragments, "browserTest").text,
-                        };
-                    case "shellcheck":
-                        return {
-                            kind: "capability",
-                            name: "shellcheck",
-                            text: requireDockerfileFragment(options.dockerfileFragments, "shellCheck").text,
-                        };
-                    case "rust":
-                        return {
-                            kind: "capability",
-                            name: "rust",
-                            text: requireDockerfileFragment(options.dockerfileFragments, "rust").text,
-                        };
-                }
-            }),
-        ],
-    });
-}
-function checkedNodePnpmDockerfileFragments(options) {
-    return [
-        {
-            source: options.dockerfileFragments.source,
-            from: options.dockerfileFragments.nodePnpm.from,
-        },
-        ...(options.additionalLayers ?? []).map((layer) => {
-            switch (layer.kind) {
-                case "browser-test":
-                    return {
-                        source: options.dockerfileFragments.source,
-                        from: requireDockerfileFragment(options.dockerfileFragments, "browserTest").from,
-                    };
-                case "shellcheck":
-                    return {
-                        source: options.dockerfileFragments.source,
-                        from: requireDockerfileFragment(options.dockerfileFragments, "shellCheck").from,
-                    };
-                case "rust":
-                    return {
-                        source: options.dockerfileFragments.source,
-                        from: requireDockerfileFragment(options.dockerfileFragments, "rust")
-                            .from,
-                    };
-            }
-        }),
-    ];
-}
-function browserTestBuildArgs(layers = []) {
-    const browserTestLayer = layers.find((layer) => layer.kind === "browser-test");
-    return browserTestLayer === undefined
-        ? {}
-        : { PLAYWRIGHT_CLI_PACKAGE: browserTestLayer.playwrightCliPackage };
-}
-function rustBuildArgs(layers = []) {
-    const rustLayer = layers.find((layer) => layer.kind === "rust");
-    return rustLayer === undefined ? {} : { RUST_TOOLCHAIN: rustLayer.toolchain };
-}
-export function dockerfileFirstNodePnpmDevcontainer(options) {
-    return {
-        devcontainer: {
-            name: options.name,
-            build: {
-                dockerfile: "Dockerfile",
-                args: {
-                    NODE_VERSION: options.layer.nodeVersion,
-                    PACKAGE_MANAGER_PIN: options.layer.packageManagerPin,
-                },
-            },
-            customizations: {
-                vscode: {
-                    extensions: options.extensions,
-                    ...(options.settings ? { settings: options.settings } : {}),
-                },
-            },
-        },
-        dockerfile: [
-            `FROM mcr.microsoft.com/devcontainers/typescript-node:${options.layer.nodeVersion}`,
-            "",
-            'SHELL ["/bin/bash", "-o", "pipefail", "-c"]',
-            `RUN corepack enable && corepack prepare ${options.layer.packageManagerPin} --activate`,
-            "",
-        ].join("\n"),
-    };
-}
-export function checkedDockerfileFirstNodePnpmDevcontainer(options) {
-    return {
-        devcontainer: {
-            name: options.name,
-            build: {
-                dockerfile: "Dockerfile",
-                args: {
-                    NODE_VERSION: options.layer.nodeVersion,
-                    PACKAGE_MANAGER_PIN: options.layer.packageManagerPin,
-                    ...browserTestBuildArgs(options.additionalLayers),
-                    ...rustBuildArgs(options.additionalLayers),
-                },
-            },
-            customizations: {
-                vscode: {
-                    extensions: options.extensions,
-                    ...(options.settings ? { settings: options.settings } : {}),
-                },
-            },
-            ...(options.mounts ? { mounts: options.mounts } : {}),
-        },
-        dockerfile: checkedNodePnpmDockerfile({
-            dockerfileFragments: options.dockerfileFragments,
-            additionalLayers: options.additionalLayers,
-        }),
-        dockerfileOperation: {
-            kind: "writeTextFromFragments",
-            to: ".devcontainer/Dockerfile",
-            fragments: checkedNodePnpmDockerfileFragments({
-                dockerfileFragments: options.dockerfileFragments,
-                additionalLayers: options.additionalLayers,
-            }),
-        },
-    };
-}
-export function dockerfileFirstRustPnpmDevcontainer(options) {
-    return checkedDockerfileFirstNodePnpmDevcontainer({
-        name: options.name,
-        layer: options.nodeLayer,
-        dockerfileFragments: options.dockerfileFragments,
-        additionalLayers: [options.rustLayer],
-        extensions: options.extensions,
-        settings: options.settings,
-        mounts: [
-            "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
-            "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
-            "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume",
-        ],
-    });
-}