@ykdz/template 0.0.30 → 0.0.32

package/node_modules/@ykdz/template-core/dist/development-container-tool-layer.js

@@ -0,0 +1,361 @@
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveTemplateSource, } from "./renderer.js";
+function hasContinuation(line, escapeCharacter) {
+    const trimmed = line.trimEnd();
+    let escapeCount = 0;
+    for (let index = trimmed.length - 1; index >= 0 && trimmed[index] === escapeCharacter; index -= 1) {
+        escapeCount += 1;
+    }
+    return escapeCount % 2 === 1;
+}
+function parseLogicalDockerfileInstructions(text, sourceFile) {
+    const instructions = [];
+    let escapeCharacter = "\\";
+    let logicalLine = "";
+    for (const physicalLine of text.split(/\r?\n/u)) {
+        const trimmed = physicalLine.trim();
+        if (logicalLine.length === 0 && trimmed.startsWith("#")) {
+            const escapeDirective = trimmed.match(/^#\s*escape\s*=\s*([\\`])\s*$/iu);
+            if (escapeDirective?.[1] !== undefined) {
+                escapeCharacter = escapeDirective[1];
+            }
+            continue;
+        }
+        if (trimmed.length === 0 || trimmed.startsWith("#")) {
+            continue;
+        }
+        const continuation = hasContinuation(physicalLine, escapeCharacter);
+        const physicalContent = continuation
+            ? physicalLine.trimEnd().slice(0, -1)
+            : physicalLine;
+        logicalLine += physicalContent.trimStart();
+        if (continuation) {
+            continue;
+        }
+        const match = logicalLine.match(/^([A-Za-z]+)(?:[ \t]+(.*))?$/u);
+        if (match?.[1] === undefined) {
+            throw new Error(`Development Container Dockerfile fragment ${sourceFile} contains an invalid logical instruction: ${logicalLine}`);
+        }
+        instructions.push({
+            name: match[1].toUpperCase(),
+            arguments: match[2] ?? "",
+        });
+        logicalLine = "";
+    }
+    if (logicalLine.length > 0) {
+        throw new Error(`Development Container Dockerfile fragment ${sourceFile} ends with an unterminated line continuation.`);
+    }
+    return instructions;
+}
+function instructionNames(instructions, instruction) {
+    return new Set(instructions
+        .filter(({ name }) => name === instruction)
+        .map(({ arguments: value }) => value.trim().split(/[\s=]/u)[0])
+        .filter((name) => name.length > 0));
+}
+function dockerfileWords(value) {
+    const words = [];
+    let word = "";
+    let quote;
+    let escaped = false;
+    for (const character of value) {
+        if (escaped) {
+            word += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote !== undefined) {
+            if (character === quote) {
+                quote = undefined;
+            }
+            else {
+                word += character;
+            }
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (/\s/u.test(character)) {
+            if (word.length > 0) {
+                words.push(word);
+                word = "";
+            }
+            continue;
+        }
+        word += character;
+    }
+    if (escaped) {
+        word += "\\";
+    }
+    if (word.length > 0) {
+        words.push(word);
+    }
+    return words;
+}
+function environmentNames(instructions) {
+    const names = new Set();
+    for (const instruction of instructions) {
+        if (instruction.name !== "ENV") {
+            continue;
+        }
+        const words = dockerfileWords(instruction.arguments);
+        const first = words[0];
+        if (first === undefined) {
+            continue;
+        }
+        if (!first.includes("=")) {
+            names.add(first);
+            continue;
+        }
+        for (const assignment of words) {
+            const separator = assignment.indexOf("=");
+            if (separator > 0) {
+                names.add(assignment.slice(0, separator));
+            }
+        }
+    }
+    return names;
+}
+function validateDockerfileFragment(fragment) {
+    if (!fragment.from.endsWith(".Dockerfile")) {
+        throw new Error(`Development Container Tool Layer ${fragment.identity} must reference checked .Dockerfile template source; received ${fragment.from}.`);
+    }
+    const instructions = parseLogicalDockerfileInstructions(fragment.text, fragment.from);
+    const allowedInstructions = fragment.kind === "base"
+        ? new Set(["ARG", "ENV", "FROM", "RUN", "SHELL"])
+        : new Set(["ARG", "ENV", "RUN"]);
+    for (const instruction of instructions) {
+        if (!allowedInstructions.has(instruction.name)) {
+            const role = fragment.kind === "base" ? "base" : "optional";
+            const allowed = fragment.kind === "base"
+                ? "ARG, ENV, FROM, RUN, and SHELL"
+                : "ARG, ENV, and RUN";
+            throw new Error(`Development Container Tool Layer ${fragment.identity} ${role} fragment ${fragment.from} must not use Dockerfile instruction ${instruction.name}; allowed instructions are ${allowed}.`);
+        }
+    }
+    if (fragment.kind === "base") {
+        const fromCount = instructions.filter((instruction) => instruction.name === "FROM").length;
+        if (fromCount !== 1) {
+            throw new Error(`Development Container Tool Layer ${fragment.identity} base fragment ${fragment.from} must contain exactly one FROM instruction; found ${fromCount}.`);
+        }
+    }
+    return instructions;
+}
+export function validateDevelopmentContainerDockerfileFragments(options) {
+    validateDockerfileFragment({ ...options.baseFragment, kind: "base" });
+    for (const fragment of options.fragments ?? []) {
+        validateDockerfileFragment({ ...fragment, kind: "optional" });
+    }
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function assertDockerfileTemplateSource(layer) {
+    if (!layer.dockerfile.from.endsWith(".Dockerfile")) {
+        throw new Error(`Development Container Tool Layer ${layer.identity} must reference checked .Dockerfile template source; received ${layer.dockerfile.from}.`);
+    }
+}
+function normalizeLayer(layer) {
+    assertDockerfileTemplateSource(layer);
+    const buildArgumentNames = new Set();
+    for (const argument of layer.buildArguments ?? []) {
+        if (buildArgumentNames.has(argument.name)) {
+            throw new Error(`Development Container Tool Layer ${layer.identity} declares build argument ${argument.name} more than once.`);
+        }
+        buildArgumentNames.add(argument.name);
+    }
+    return {
+        ...layer,
+        requires: [...new Set(layer.requires ?? [])].toSorted(compareText),
+        buildArguments: [...(layer.buildArguments ?? [])].toSorted((left, right) => compareText(left.name, right.name) ||
+            compareText(left.value, right.value)),
+        mounts: [...(layer.mounts ?? [])]
+            .map((mount) => ({
+            ...mount,
+            target: path.posix.normalize(mount.target),
+        }))
+            .toSorted((left, right) => compareText(left.identity, right.identity) ||
+            compareText(left.target, right.target)),
+        probes: [...(layer.probes ?? [])]
+            .map((probe) => ({
+            ...probe,
+            args: [...(probe.args ?? [])],
+        }))
+            .toSorted((left, right) => compareText(left.identity, right.identity) ||
+            compareText(left.command, right.command) ||
+            compareText(JSON.stringify(left.args), JSON.stringify(right.args))),
+    };
+}
+function layerFingerprint(layer, kind) {
+    return JSON.stringify({
+        kind,
+        identity: layer.identity,
+        dockerfile: resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from),
+        requires: layer.requires,
+        buildArguments: layer.buildArguments,
+        mounts: layer.mounts,
+        probes: layer.probes,
+    });
+}
+function findDependencyCycle(layers) {
+    const byIdentity = new Map(layers.map((layer) => [layer.identity, layer]));
+    const complete = new Set();
+    const active = [];
+    const activeSet = new Set();
+    const visit = (identity) => {
+        if (activeSet.has(identity)) {
+            return active.slice(active.indexOf(identity)).toSorted(compareText);
+        }
+        if (complete.has(identity)) {
+            return undefined;
+        }
+        active.push(identity);
+        activeSet.add(identity);
+        const layer = byIdentity.get(identity);
+        for (const dependency of layer?.requires ?? []) {
+            if (!byIdentity.has(dependency)) {
+                continue;
+            }
+            const cycle = visit(dependency);
+            if (cycle !== undefined) {
+                return cycle;
+            }
+        }
+        active.pop();
+        activeSet.delete(identity);
+        complete.add(identity);
+        return undefined;
+    };
+    for (const identity of [...byIdentity.keys()].toSorted(compareText)) {
+        const cycle = visit(identity);
+        if (cycle !== undefined) {
+            return cycle;
+        }
+    }
+    return undefined;
+}
+function orderLayers(baseLayer, optionalLayers) {
+    const normalizedBase = normalizeLayer(baseLayer);
+    if ((normalizedBase.requires?.length ?? 0) > 0) {
+        throw new Error(`Development Container Tool Layer ${normalizedBase.identity} is the base foundation and must not require other layers.`);
+    }
+    const base = {
+        ...normalizedBase,
+        kind: "base",
+    };
+    const identities = new Map([[base.identity, layerFingerprint(base, "base")]]);
+    const uniqueOptionalLayers = [];
+    for (const layer of optionalLayers) {
+        const normalized = normalizeLayer(layer);
+        const fingerprint = layerFingerprint(normalized, "optional");
+        const previous = identities.get(normalized.identity);
+        if (previous === fingerprint) {
+            continue;
+        }
+        if (previous !== undefined) {
+            throw new Error(`Development Container Tool Layer identity ${normalized.identity} has conflicting descriptors.`);
+        }
+        identities.set(normalized.identity, fingerprint);
+        uniqueOptionalLayers.push(normalized);
+    }
+    for (const layer of uniqueOptionalLayers) {
+        for (const requiredIdentity of layer.requires ?? []) {
+            if (!identities.has(requiredIdentity)) {
+                throw new Error(`Development Container Tool Layer ${layer.identity} requires missing layer ${requiredIdentity}.`);
+            }
+        }
+    }
+    const cycle = findDependencyCycle(uniqueOptionalLayers);
+    if (cycle !== undefined) {
+        throw new Error(`Development Container Tool Layer dependency cycle involves: ${cycle.join(", ")}.`);
+    }
+    const remaining = uniqueOptionalLayers
+        .map((layer) => ({
+        ...layer,
+        kind: "optional",
+    }))
+        .toSorted((left, right) => compareText(left.identity, right.identity));
+    const ordered = [base];
+    const resolved = new Set([base.identity]);
+    while (remaining.length > 0) {
+        const readyIndex = remaining.findIndex((layer) => (layer.requires ?? []).every((identity) => resolved.has(identity)));
+        if (readyIndex === -1) {
+            throw new Error("Development Container Tool Layer dependencies cannot be resolved.");
+        }
+        const [next] = remaining.splice(readyIndex, 1);
+        if (next === undefined) {
+            throw new Error("Development Container Tool Layer dependency resolution failed.");
+        }
+        ordered.push(next);
+        resolved.add(next.identity);
+    }
+    return ordered;
+}
+function completeDevelopmentContainerToolLayerPlan(layers, fragmentTexts) {
+    const buildArgumentOwners = new Map();
+    const environmentOwners = new Map();
+    const mountIdentityOwners = new Map();
+    const mountTargetOwners = new Map();
+    for (const [index, layer] of layers.entries()) {
+        for (const mount of layer.mounts ?? []) {
+            const previousIdentityOwner = mountIdentityOwners.get(mount.identity);
+            if (previousIdentityOwner !== undefined) {
+                throw new Error(`Development Container Tool Layer mount identity ${mount.identity} is declared by both ${previousIdentityOwner} and ${layer.identity}.`);
+            }
+            const previousTargetOwner = mountTargetOwners.get(mount.target);
+            if (previousTargetOwner !== undefined) {
+                throw new Error(`Development Container Tool Layer mount target ${mount.target} is declared by both ${previousTargetOwner} and ${layer.identity}.`);
+            }
+            mountIdentityOwners.set(mount.identity, layer.identity);
+            mountTargetOwners.set(mount.target, layer.identity);
+        }
+        const instructions = validateDockerfileFragment({
+            identity: layer.identity,
+            kind: layer.kind,
+            from: layer.dockerfile.from,
+            text: fragmentTexts[index],
+        });
+        const declaredArguments = instructionNames(instructions, "ARG");
+        for (const name of declaredArguments) {
+            const previousOwner = buildArgumentOwners.get(name);
+            if (previousOwner !== undefined) {
+                throw new Error(`Development Container Tool Layer build argument ${name} is declared by both ${previousOwner} and ${layer.identity}.`);
+            }
+            buildArgumentOwners.set(name, layer.identity);
+        }
+        for (const name of environmentNames(instructions)) {
+            const previousOwner = environmentOwners.get(name);
+            if (previousOwner !== undefined) {
+                throw new Error(`Development Container Tool Layer environment ${name} is declared by both ${previousOwner} and ${layer.identity}.`);
+            }
+            environmentOwners.set(name, layer.identity);
+        }
+        for (const argument of layer.buildArguments ?? []) {
+            if (!declaredArguments.has(argument.name)) {
+                throw new Error(`Development Container Tool Layer ${layer.identity} supplies build argument ${argument.name}, but ${layer.dockerfile.from} does not declare it with ARG.`);
+            }
+        }
+    }
+    return {
+        layers,
+        buildArguments: layers.flatMap((layer) => layer.buildArguments ?? []),
+        mounts: layers.flatMap((layer) => layer.mounts ?? []),
+        probes: layers.flatMap((layer) => layer.probes ?? []),
+    };
+}
+export function planDevelopmentContainerToolLayersSync(options) {
+    const layers = orderLayers(options.baseLayer, options.layers ?? []);
+    return completeDevelopmentContainerToolLayerPlan(layers, layers.map((layer) => readFileSync(resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from), "utf8")));
+}
+export async function planDevelopmentContainerToolLayers(options) {
+    const layers = orderLayers(options.baseLayer, options.layers ?? []);
+    return completeDevelopmentContainerToolLayerPlan(layers, await Promise.all(layers.map((layer) => readFile(resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from), "utf8"))));
+}

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

@@ -1,8 +1,9 @@
+import type { DevelopmentContainerToolLayer } from "./development-container-tool-layer.ts";
 import type { EditorCustomizationCapability } from "./editor-customization.ts";
 import type { CheckEnvironmentNeed, DeploymentEnvironmentNeed } from "./module-graph.ts";
 import type { PackageDefinition } from "./project-blueprint-v2.ts";
 import type { DependencyMaintenancePolicy } from "./project-github.ts";
-import type { RenderOperation } from "./renderer.ts";
+import type { RenderOperation, TemplateSourceHandle } from "./renderer.ts";
 export type FoundationContribution = {
     /** Toolchains the Foundation must install and project into coordinated root files. */
     readonly toolchains: {
@@ -19,6 +20,16 @@ export type FoundationContribution = {
     readonly workspacePackageGlobs?: readonly string[];
     /** Dependency Catalog entries required by package-owned manifests. */
     readonly dependencyCatalog?: Readonly<Record<string, string>>;
+    /** Source-backed Development Container capabilities coordinated by Foundation. */
+    readonly developmentContainerToolLayers?: readonly DevelopmentContainerToolLayer[] | undefined;
+    /** Source-backed coordinated files projected by Foundation. */
+    readonly templateFiles?: readonly {
+        readonly identity: string;
+        readonly source: TemplateSourceHandle;
+        readonly from: string;
+        readonly to: string;
+        readonly replacements?: Readonly<Record<string, string>> | undefined;
+    }[] | undefined;
 };
 /** A preset-agnostic package-sized part of a Generated Repository Plan. */
 export type PackageContribution = {

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -21,13 +21,15 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
-  "@hono/node-server": ^2.0.6
+  "@devcontainers/cli": 0.88.0
+  "@hono/node-server": ^2.0.12
   "@playwright/test": ^1.61.1
-  "@tailwindcss/vite": ^4.3.2
+  "@tailwindcss/vite": ^4.3.3
   "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
   "@vitejs/plugin-vue": ^6.0.8
   "@vikejs/hono": ^0.2.1
+  "@vue/devtools-api": ^8.1.5
   "@vue/tsconfig": ^0.9.1
   commander: ^15.0.0
   drizzle-kit: 1.0.0-rc.4
@@ -37,10 +39,10 @@ catalog:
   node-diff3: ^3.2.1
   oxfmt: ^0.58.0
   oxlint: ^1.73.0
-  oxlint-tsgolint: ^0.24.0
+  oxlint-tsgolint: ^7.0.2001
   semver: ^7.8.5
   "@types/semver": ^7.7.1
-  pinia: ^3.0.4
+  pinia: ^4.0.2
   srvx: ^0.12.1
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
@@ -48,7 +50,7 @@ catalog:
   typescript: npm:@typescript/typescript6@^6.0.2
   typescript-7: npm:typescript@^7.0.2
   valibot: ^1.4.2
-  vite: ^8.1.4
+  vite: ^8.1.5
   vike: ^0.4.260
   vike-vue: ^0.9.12
   vitest: ^4.1.10

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

@@ -1,4 +1,4 @@
-import { type CheckEnvironmentNeed, type DeploymentEnvironmentNeed } from "./module-graph.ts";
+import type { DeploymentEnvironmentNeed } from "./module-graph.ts";
 export type CiCapability = {
     readonly workflowName: "Check";
     readonly jobName: "check";
@@ -6,7 +6,6 @@ export type CiCapability = {
 };
 export type CiEnvironmentPreparation = {
     readonly nodeFromPackageMetadata: boolean;
-    readonly rustToolchain: boolean;
 };
 export type PnpmTaskLayer = {
     readonly installCommand: "pnpm install";
@@ -21,9 +20,6 @@ export type DependencyMaintenancePolicy = {
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
-    readonly environment: {
-        readonly needs: readonly CheckEnvironmentNeed[];
-    };
     readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
     readonly hasDeploymentTask?: boolean | undefined;
     readonly capability?: CiCapability | undefined;
@@ -33,12 +29,8 @@ type ProjectCheckWorkflowOptions = {
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 /** Limited substitutions for the Foundation-owned workflow Template Source. */
 export declare function projectCheckWorkflowTemplateReplacements(options: {
-    readonly environment: {
-        readonly needs: readonly CheckEnvironmentNeed[];
-    };
     readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
     readonly hasDeploymentTask?: boolean | undefined;
-    readonly environmentPreparation?: Partial<CiEnvironmentPreparation>;
 }): Record<string, string>;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;
 /** Limited substitution for the Foundation-owned Dependabot Template Source. */

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

@@ -1,4 +1,3 @@
-import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -12,11 +11,8 @@ export function projectCheckWorkflow(options) {
     const capability = options.capability ?? defaultCiCapability;
     const environmentPreparation = {
         nodeFromPackageMetadata: true,
-        rustToolchain: false,
         ...options.environmentPreparation,
     };
-    const requiresRustToolchain = environmentPreparation.rustToolchain ||
-        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
     const hasDeploymentTask = options.hasDeploymentTask === true;
     const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
@@ -44,20 +40,7 @@ export function projectCheckWorkflow(options) {
     if (hasDeploymentTask && needsDocker) {
         lines.push("      - uses: docker/setup-buildx-action@v3", "        if: matrix.check == 'deployment'");
     }
-    if (requiresRustToolchain)
-        lines.push(...rustCiPreparationLines());
     lines.push(`      - run: ${taskLayer.installCommand}`);
-    const checkEnvironmentLines = [];
-    for (const need of options.environment.needs) {
-        if (need.kind === "rust-toolchain") {
-            continue;
-        }
-        checkEnvironmentLines.push(`      - run: ${renderCiEnvironmentNeedCommand(need)}`);
-        if (hasDeploymentTask && need.kind === "shellcheck-command") {
-            checkEnvironmentLines.push("        if: matrix.check == 'root'");
-        }
-    }
-    lines.push(...checkEnvironmentLines);
     lines.push(`      - run: ${taskLayer.checkCommand}`);
     if (hasDeploymentTask) {
         lines.push("        if: matrix.check == 'root'");
@@ -68,33 +51,11 @@ export function projectCheckWorkflow(options) {
     lines.push("");
     return lines.join("\n");
 }
-function rustCiPreparationLines() {
-    return [
-        "      - uses: dtolnay/rust-toolchain@stable",
-        "        with:",
-        "          components: rustfmt, clippy",
-        "      - uses: Swatinem/rust-cache@v2",
-    ];
-}
 /** Limited substitutions for the Foundation-owned workflow Template Source. */
 export function projectCheckWorkflowTemplateReplacements(options) {
-    const requiresRustToolchain = options.environmentPreparation?.rustToolchain === true ||
-        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const hasDeploymentTask = options.hasDeploymentTask === true;
     const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
-    const environmentSteps = options.environment.needs
-        .filter((need) => need.kind !== "rust-toolchain")
-        .map((need) => [
-        `      - run: ${renderCiEnvironmentNeedCommand(need)}`,
-        ...(hasDeploymentTask && need.kind === "shellcheck-command"
-            ? ["        if: matrix.check == 'root'"]
-            : []),
-    ].join("\n"));
     return {
-        RUST_CI_PREPARATION: requiresRustToolchain
-            ? `\n${rustCiPreparationLines().join("\n")}`
-            : "",
-        CHECK_ENVIRONMENT_PREPARATION: environmentSteps.length === 0 ? "" : `\n${environmentSteps.join("\n")}`,
         DEPLOYMENT_MATRIX: hasDeploymentTask
             ? "\n    strategy:\n      matrix:\n        check: [root, deployment]"
             : "",
@@ -152,13 +113,3 @@ function renderDependabotDirectory(ecosystem, directory) {
 function defaultDependabotDirectory(ecosystem) {
     return ecosystem === "docker" ? "/.devcontainer" : "/";
 }
-function renderCiEnvironmentNeedCommand(need) {
-    switch (need.kind) {
-        case "playwright-browser-assets":
-            return renderPlaywrightBrowserInstallCommand(need, { withDeps: true });
-        case "shellcheck-command":
-            return need.nextStep.display;
-        case "rust-toolchain":
-            return need.nextStep.display;
-    }
-}

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

@@ -17,6 +17,15 @@ export type StructuredIdentitySetPolicy = {
     } | {
         readonly kind: "fields";
         readonly fields: readonly string[];
+    } | {
+        readonly kind: "projection";
+        readonly members: readonly {
+            readonly identity: string;
+            readonly match: Readonly<Record<string, string | number | boolean | null>>;
+        }[];
+        readonly fallback: {
+            readonly fields: readonly string[];
+        };
     };
 };
 export type ProjectProjectionReconciliation = {