@ykdz/template 0.0.31 → 0.0.33

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;
     }
@@ -568,9 +589,170 @@ function pushSourceBackedOperationViolations(options) {
         });
     }
 }
-export async function checkTemplateSourceBoundary({ projections, templateSourceContexts = [], manifestReferencedSourceFiles = [], }) {
+const workflowTemplateVariants = new Map([
+    [
+        ".github/workflows/check.yml",
+        { operationKind: "copyFile", replacementKeys: [] },
+    ],
+    [
+        ".github/workflows/check-deployment.yml",
+        { operationKind: "copyFile", replacementKeys: [] },
+    ],
+    [
+        ".github/workflows/check-diagnostics.yml",
+        {
+            operationKind: "writeTextTemplate",
+            replacementKeys: ["DIAGNOSTIC_OWNER_PATHS"],
+        },
+    ],
+    [
+        ".github/workflows/check-deployment-diagnostics.yml",
+        {
+            operationKind: "writeTextTemplate",
+            replacementKeys: ["DIAGNOSTIC_OWNER_PATHS"],
+        },
+    ],
+]);
+function hasExactReplacementKeys(replacements, expectedKeys) {
+    const keys = Object.keys(replacements).toSorted();
+    const expected = [...expectedKeys].toSorted();
+    return (keys.length === expected.length &&
+        keys.every((key, index) => key === expected[index]));
+}
+const reservedWorkspaceCollections = new Set([
+    ".git",
+    ".github",
+    ".devcontainer",
+    ".template",
+    "node_modules",
+    "dist",
+    "target",
+]);
+function isSafePackageBoundaryPath(value) {
+    return (/^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/u.test(value) &&
+        !reservedWorkspaceCollections.has(value.split("/", 1)[0]));
+}
+/**
+ * Independent oracle for the Foundation workflow's limited substitution.
+ * It deliberately consumes raw Blueprint and Package Contribution facts rather
+ * than the production CI artifact composer or its composed plan output.
+ */
+function expectedDiagnosticOwnerPaths(options) {
+    const blueprintPackagePaths = options.blueprint.packages.map((packageDefinition) => packageDefinition.path);
+    if (!blueprintPackagePaths.every(isSafePackageBoundaryPath)) {
+        return { valid: false, value: "" };
+    }
+    const blueprintOwners = new Set(blueprintPackagePaths);
+    const owners = new Set();
+    for (const declaration of options.diagnosticArtifactDeclarations) {
+        if (!isRecord(declaration) ||
+            !hasExactKeys(declaration, ["kind", "owner"])) {
+            return { valid: false, value: "" };
+        }
+        if (declaration.kind !== "playwright" || !isRecord(declaration.owner)) {
+            return { valid: false, value: "" };
+        }
+        if (!hasExactKeys(declaration.owner, ["kind", "path"])) {
+            return { valid: false, value: "" };
+        }
+        const ownerPath = declaration.owner.path;
+        if (declaration.owner.kind !== "package-boundary" ||
+            typeof ownerPath !== "string" ||
+            !isSafePackageBoundaryPath(ownerPath) ||
+            !blueprintOwners.has(ownerPath)) {
+            return { valid: false, value: "" };
+        }
+        owners.add(ownerPath);
+    }
+    return {
+        valid: true,
+        value: [...owners].toSorted().join("\n            "),
+    };
+}
+function sourceFileForWorkflowOperation(options) {
+    return options.operation?.provenance?.plannerSourceFile ?? options.fallback;
+}
+function findWorkflowOperationOwners(sourceFile, operation) {
+    if (operation === undefined)
+        return ["<unknown>"];
+    const targetPath = operationTarget(operation);
+    if (targetPath === undefined)
+        return ["<unknown>"];
+    const expectedTargetPath = targetPath;
+    const operationKind = operation.kind;
+    const owners = new Set();
+    function visit(node) {
+        if (ts.isObjectLiteralExpression(node)) {
+            if (propertyStringValue(node, "kind") === operationKind &&
+                propertyPathMatches(node, "to", expectedTargetPath)) {
+                owners.add(owningFunctionName(node));
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return owners.size === 0 ? ["<unknown>"] : [...owners];
+}
+async function protectedWorkflowProjectionViolations(plans) {
+    const violations = [];
+    for (const plan of plans) {
+        const matchingOperations = plan.operations.filter((operation) => operationTarget(operation) === plan.generatedPath);
+        const operation = matchingOperations[0];
+        const sourceFilePath = sourceFileForWorkflowOperation({
+            operation,
+            fallback: plan.sourceFilePath,
+        });
+        const sourceText = await readFile(sourceFilePath, "utf8");
+        const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const expectedDiagnosticOwners = expectedDiagnosticOwnerPaths(plan);
+        const variant = operation !== undefined &&
+            (operation.kind === "copyFile" || operation.kind === "writeTextTemplate")
+            ? workflowTemplateVariants.get(operation.from)
+            : undefined;
+        const replacementValid = operation?.kind === "writeTextTemplate" &&
+            hasExactReplacementKeys(operation.replacements, [
+                "DIAGNOSTIC_OWNER_PATHS",
+            ]) &&
+            operation.replacements.DIAGNOSTIC_OWNER_PATHS ===
+                expectedDiagnosticOwners.value;
+        const sourceBackedExactlyOnce = matchingOperations.length === 1 &&
+            operation !== undefined &&
+            (operation.kind === "copyFile" || operation.kind === "writeTextTemplate");
+        const diagnosticsExpected = expectedDiagnosticOwners.value !== "";
+        const operationValid = expectedDiagnosticOwners.valid &&
+            sourceBackedExactlyOnce &&
+            variant !== undefined &&
+            operation?.kind === variant.operationKind &&
+            (operation.kind === "copyFile"
+                ? variant.replacementKeys.length === 0 && !diagnosticsExpected
+                : variant.replacementKeys.length === 1 &&
+                    diagnosticsExpected &&
+                    replacementValid);
+        if (operationValid)
+            continue;
+        for (const owningFunction of findWorkflowOperationOwners(sourceFile, operation)) {
+            violations.push({
+                preset: plan.name,
+                generatedPath: plan.generatedPath,
+                owningFunction,
+                operationKind: operation?.kind ?? "writeTextTemplate",
+                sourceFilePath,
+                ...(plan.definitionName === undefined
+                    ? {}
+                    : { definitionName: plan.definitionName }),
+                ...(plan.planningContribution === undefined
+                    ? {}
+                    : { planningContribution: plan.planningContribution }),
+                ownershipRule: "Foundation workflow projections require exactly one source-backed template operation with closed diagnostic owner facts",
+            });
+        }
+    }
+    return violations;
+}
+export async function checkTemplateSourceBoundary({ projections, templateSourceContexts = [], manifestReferencedSourceFiles = [], protectedWorkflowPlans = [], }) {
     const manifestReferencedSourceFileSet = new Set(manifestReferencedSourceFiles.map((sourceFile) => path.resolve(sourceFile)));
     const violations = [];
+    violations.push(...(await protectedWorkflowProjectionViolations(protectedWorkflowPlans)));
     for (const projection of projections) {
         const sourceText = await readFile(projection.sourceFilePath, "utf8");
         const sourceFile = ts.createSourceFile(projection.sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ykdz/template",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "private": false,
   "description": "Project template generator for YKDZ starter projects.",
   "keywords": [

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/.github/workflows/check-playwright.yml

@@ -1,20 +0,0 @@
-name: Check
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version-file: package.json
-      - run: corepack enable
-      - run: pnpm install
-      - run: pnpm --filter ./apps/web exec playwright install --with-deps chromium
-      - run: pnpm run check

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/.github/workflows/check-rust.yml

@@ -1,23 +0,0 @@
-name: Check
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version-file: package.json
-      - run: corepack enable
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-      - uses: Swatinem/rust-cache@v2
-      - run: pnpm install
-      - run: pnpm run check

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/.github/workflows/check.dynamic.template

@@ -1,19 +0,0 @@
-name: Check
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-jobs:
-  check:
-    runs-on: ubuntu-latest{{DEPLOYMENT_MATRIX}}
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version-file: package.json
-      - run: corepack enable{{RUST_CI_PREPARATION}}{{DEPLOYMENT_DOCKER_PREPARATION}}
-      - run: pnpm install{{CHECK_ENVIRONMENT_PREPARATION}}
-      - run: pnpm run check{{ROOT_CHECK_CONDITION}}{{DEPLOYMENT_CHECK}}

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",
-        ],
-    });
-}