@ykdz/template 0.0.22 → 0.0.23

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/container-entrypoint.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+set -eu
+
+database_file=${DATABASE_FILE:-/data/app.sqlite}
+container_capability=${CONTAINER_CAPABILITY:-prepare-and-start}
+prepare_database_command=${PREPARE_DATABASE_COMMAND:-/usr/local/bin/prepare-database}
+case "$database_file" in
+  /*) ;;
+  *)
+    echo "DATABASE_FILE must be an absolute path: $database_file" >&2
+    exit 64
+    ;;
+esac
+
+prepare_database() {
+  "$prepare_database_command" "$database_file"
+}
+
+if [ "$container_capability" = "start-only" ]; then
+  case "${1:-}" in
+    start-only)
+      exec node /app/dist/server/index.mjs
+      ;;
+    prepare-only | prepare-and-start)
+      echo "Container capability 'start-only' does not support '${1}'." >&2
+      exit 64
+      ;;
+    *)
+      echo "Unsupported container command '${1:-}'. Expected start-only." >&2
+      exit 64
+      ;;
+  esac
+fi
+
+if [ "$container_capability" != "prepare-and-start" ]; then
+  echo "Unsupported CONTAINER_CAPABILITY '$container_capability'." >&2
+  exit 64
+fi
+
+case "${1:-}" in
+  prepare-only)
+    prepare_database
+    ;;
+  prepare-and-start)
+    prepare_database
+    exec node /app/dist/server/index.mjs
+    ;;
+  *)
+    echo "Unsupported container command '${1:-}'. Expected prepare-only or prepare-and-start." >&2
+    exit 64
+    ;;
+esac

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/prepare-database.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+set -eu
+
+database_file=$1
+mkdir -p "$(dirname "$database_file")"
+DATABASE_FILE="$database_file" pnpm --dir /repo/packages/db run db:prepare:deploy

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/run-playwright.ts

@@ -1,11 +1,38 @@
 import { spawn } from "node:child_process";
-import { rm } from "node:fs/promises";
+import { mkdir, rm } from "node:fs/promises";
 import { createServer } from "node:net";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const databaseFile = fileURLToPath(
   new URL("../node_modules/.tmp/e2e.sqlite", import.meta.url),
 );
+const externalBaseUrlName = "PLAYWRIGHT_EXTERNAL_BASE_URL";
+const externalReadinessTimeoutMs = 30_000;
+
+function externalBaseUrl(): string | undefined {
+  if (!Object.hasOwn(process.env, externalBaseUrlName)) {
+    return undefined;
+  }
+
+  const value = process.env[externalBaseUrlName]?.trim();
+  if (!value) {
+    throw new Error(`${externalBaseUrlName} must be a non-empty HTTP(S) URL`);
+  }
+
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${externalBaseUrlName} must be a valid HTTP(S) URL`);
+  }
+
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`${externalBaseUrlName} must use HTTP or HTTPS`);
+  }
+
+  return url.toString();
+}
 
 async function availablePort(): Promise<string> {
   return await new Promise((resolve, reject) => {
@@ -35,7 +62,30 @@ async function availablePort(): Promise<string> {
   });
 }
 
-async function playwrightEnv(): Promise<NodeJS.ProcessEnv> {
+async function awaitExternalService(baseUrl: string): Promise<void> {
+  const deadline = Date.now() + externalReadinessTimeoutMs;
+
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(baseUrl, {
+        signal: AbortSignal.timeout(2_000),
+      });
+      if (response.ok) {
+        return;
+      }
+    } catch {
+      // The externally managed service may still be starting.
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+
+  throw new Error(
+    `External Playwright service at ${baseUrl} was not ready within ${externalReadinessTimeoutMs}ms`,
+  );
+}
+
+async function localPlaywrightEnv(): Promise<NodeJS.ProcessEnv> {
   return {
     ...process.env,
     DATABASE_FILE: process.env.DATABASE_FILE ?? databaseFile,
@@ -44,9 +94,19 @@ async function playwrightEnv(): Promise<NodeJS.ProcessEnv> {
   };
 }
 
-const env = await playwrightEnv();
+const externalServiceUrl = externalBaseUrl();
+const env = externalServiceUrl
+  ? { ...process.env }
+  : await localPlaywrightEnv();
+const localDatabaseFile = externalServiceUrl ? undefined : env.DATABASE_FILE;
 delete env.NO_COLOR;
-await rm(env.DATABASE_FILE!, { force: true });
+
+if (externalServiceUrl) {
+  await awaitExternalService(externalServiceUrl);
+} else {
+  await mkdir(path.dirname(localDatabaseFile!), { recursive: true });
+  await rm(localDatabaseFile!, { force: true });
+}
 
 const command = process.platform === "win32" ? "playwright.cmd" : "playwright";
 const child = spawn(command, ["test", ...process.argv.slice(2)], {
@@ -54,28 +114,38 @@ const child = spawn(command, ["test", ...process.argv.slice(2)], {
   stdio: "inherit",
 });
 
-child.once("error", (error: Error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
-
-child.once("exit", (code: number | null, signal: NodeJS.Signals | null) => {
-  void rm(env.DATABASE_FILE!, { force: true }).finally(() => {
-    if (signal) {
-      console.error(`Playwright exited with signal ${signal}`);
-      process.exitCode = 1;
-      return;
-    }
+const forwardedSignals = ["SIGINT", "SIGTERM"] as const;
+const forwardSignal = (signal: NodeJS.Signals): void => {
+  child.kill(signal);
+};
+for (const signal of forwardedSignals) {
+  process.once(signal, forwardSignal);
+}
 
-    process.exitCode = code ?? 1;
+try {
+  const result = await new Promise<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+  }>((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
   });
-});
 
-for (const signal of ["SIGINT", "SIGTERM"] as const) {
-  process.once(signal, () => {
-    child.kill(signal);
-    void rm(env.DATABASE_FILE!, { force: true }).finally(() => {
-      process.exitCode = 1;
-    });
-  });
+  if (result.signal) {
+    console.error(`Playwright exited with signal ${result.signal}`);
+    process.exitCode = 1;
+  } else {
+    process.exitCode = result.code ?? 1;
+  }
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+} finally {
+  for (const signal of forwardedSignals) {
+    process.removeListener(signal, forwardSignal);
+  }
+
+  if (localDatabaseFile) {
+    await rm(localDatabaseFile, { force: true });
+  }
 }

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/server/app.ts

@@ -1,8 +1,8 @@
+// @template-anchor db-package-import
 import vike from "@vikejs/hono";
 import { Hono } from "hono";
 import { Telefunc } from "telefunc/node";
 
-// @template-anchor db-package-import
 import { api } from "#/server/api";
 
 const telefunc = new Telefunc();

package/node_modules/@ykdz/template-core/dist/dependency-catalog.js

@@ -1,6 +1,17 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const templateInternalDependencyIdentities = new Set([
+    "@typescript/native",
+    "@typescript/typescript6",
+]);
+function assertGeneratedDependencyCatalogBoundary(dependencies) {
+    for (const dependency of dependencies) {
+        if (templateInternalDependencyIdentities.has(dependency)) {
+            throw new Error(`Generated Repository Dependency Catalog cannot include template-internal dependency: ${dependency}`);
+        }
+    }
+}
 function templateRepositoryRoot() {
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
@@ -151,6 +162,7 @@ function renderCatalogKey(key) {
     return key.startsWith("@") ? JSON.stringify(key) : key;
 }
 export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependencies, templateCatalog = loadTemplateDependencyCatalog()) {
+    assertGeneratedDependencyCatalogBoundary(dependencies);
     const catalogStart = workspaceYaml
         .split(/\r?\n/)
         .findIndex((line) => line === "catalog:");
@@ -183,6 +195,7 @@ export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependen
     ].join("\n");
 }
 export function renderGeneratedPnpmWorkspaceYaml(options) {
+    assertGeneratedDependencyCatalogBoundary(options.dependencies);
     const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
     const packages = options.packages ?? ["."];
     const lines = [

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

@@ -1,4 +1,4 @@
-import { type CheckEnvironmentNeed } from "./module-graph.js";
+import { type CheckEnvironmentNeed, type DeploymentCheckEnvironmentNeed } from "./module-graph.js";
 import type { PresetSourceManifest } from "./preset-source.js";
 import { type PresetProjectionSourceRoots } from "./projection-capabilities.js";
 export type GeneratedScenarioSet = "init" | "package-addition-matrix" | "focused";
@@ -28,7 +28,8 @@ export type GeneratedScenarioCommandStep = {
     readonly args: readonly string[];
     readonly cwd: string;
     readonly display: string;
-    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"];
+    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"] | DeploymentCheckEnvironmentNeed["kind"];
+    readonly phase?: "deployment-preparation" | "deployment";
 };
 export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
     readonly env?: Record<string, string> | undefined;

package/node_modules/@ykdz/template-core/dist/generated-scenarios.js

@@ -5,7 +5,7 @@ import { PackageAdditionSupport } from "@ykdz/template-shared";
 import { execa } from "execa";
 import * as v from "valibot";
 import { assembleGenerationContext } from "./generation-context.js";
-import { playwrightBrowserAssetsEnvironmentNeed, } from "./module-graph.js";
+import { deploymentCheckEnvironmentNeeds, playwrightBrowserAssetsEnvironmentNeed, } from "./module-graph.js";
 import { planNextStepInstructions } from "./next-step-instructions.js";
 import { canPlanPackageLinkIntent, } from "./package-linking.js";
 import { findPresetSourceManifestPreset } from "./preset-source.js";
@@ -14,7 +14,7 @@ const defaultDeterministicToolchainEnv = {
     TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
 };
 const defaultFixtureConcurrency = 2;
-const scenarioFingerprintVersion = 1;
+const scenarioFingerprintVersion = 2;
 const storedBlueprintSchema = v.object({
     packages: v.optional(v.array(v.object({
         name: v.string(),
@@ -235,6 +235,11 @@ async function writeScenarioReplayMarker(cache, fingerprint, scenario) {
     await mkdir(cache.directory, { recursive: true });
     await writeFile(path.join(cache.directory, `${fingerprint}.passed`), `${JSON.stringify({ scenario, fingerprint })}\n`, "utf8");
 }
+function deploymentReplayFingerprint(fingerprint) {
+    return createHash("sha256")
+        .update(`${fingerprint}\0docker-engine-available`)
+        .digest("hex");
+}
 export function packageLeafNameForAddedPreset(manifest, presetName) {
     const preset = manifest.presets.find((entry) => entry.name === presetName);
     if (!preset) {
@@ -392,6 +397,36 @@ function machineVerifiableNextStepsForPreset(presetName, projectDir, manifest, o
         };
     });
 }
+function deploymentStepsForPreset(presetName, scenario, projectDir, manifest, options) {
+    if (scenario.set === "init") {
+        return [];
+    }
+    const deploymentChecks = projectionPlanForPreset(presetName, projectDir, manifest, options).checkPlan
+        .deploymentChecks ?? [];
+    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
+    if (!needsDocker) {
+        return [];
+    }
+    return [
+        {
+            id: "check-docker-engine",
+            command: "docker",
+            args: ["info", "--format", "{{.ServerVersion}}"],
+            cwd: projectDir,
+            display: "docker info --format {{.ServerVersion}}",
+            environmentNeedKind: "docker-engine",
+            phase: "deployment-preparation",
+        },
+        {
+            id: "run-deployment-check",
+            command: "pnpm",
+            args: ["run", "check:deployment"],
+            cwd: projectDir,
+            display: "pnpm run check:deployment",
+            phase: "deployment",
+        },
+    ];
+}
 function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, options) {
     if (!scenario.addedPreset || !addedPackagePath) {
         return [];
@@ -431,30 +466,37 @@ export function generatedScenarioQualityGateSteps(manifest, scenario, projectDir
     const addedEnvironmentSteps = generatedScenarioEnvironmentNeedSteps(addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, normalizedOptions), projectDir);
     const existingDisplays = new Set(steps.map((step) => step.display));
     const extraEnvironmentSteps = addedEnvironmentSteps.filter((step) => !existingDisplays.has(step.display));
+    const deploymentSteps = deploymentStepsForPreset(scenario.basePreset, scenario, projectDir, manifest, normalizedOptions);
     if (extraEnvironmentSteps.length === 0) {
-        return steps;
+        return [...steps, ...deploymentSteps];
     }
     const rootCheckIndex = steps.findIndex((step) => step.id === "run-root-check");
     if (rootCheckIndex === -1) {
-        return [...steps, ...extraEnvironmentSteps];
+        return [...steps, ...extraEnvironmentSteps, ...deploymentSteps];
     }
     return [
         ...steps.slice(0, rootCheckIndex),
         ...extraEnvironmentSteps,
         ...steps.slice(rootCheckIndex),
+        ...deploymentSteps,
     ];
 }
 async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options) {
     const steps = generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options);
     const requiresSerializedPlaywrightRootCheck = generatedScenarioRequiresSerializedRootCheck(steps);
     let replayFingerprint;
+    let baseQualityGateReplayed = false;
+    let baseQualityGateMarkerWritten = false;
     for (const step of steps) {
         if (step.id === "install-dependencies") {
             const installResult = await runGeneratedScenarioInstallStep(step, scenario, options);
             replayFingerprint = installResult.fingerprint;
-            if (installResult.replayed) {
-                return;
-            }
+            baseQualityGateReplayed = installResult.baseQualityGateReplayed;
+            continue;
+        }
+        if (baseQualityGateReplayed &&
+            step.phase !== "deployment-preparation" &&
+            step.phase !== "deployment") {
             continue;
         }
         const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
@@ -464,13 +506,57 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
                 logPrefix: scenario.label,
             });
         };
+        if (step.environmentNeedKind === "docker-engine") {
+            try {
+                await runStep();
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                options.reporter.info?.(`-- Skipping deployment check for ${scenario.label}: Docker engine is unavailable (${reason})`);
+                break;
+            }
+            continue;
+        }
+        if (step.phase === "deployment") {
+            const deploymentFingerprint = replayFingerprint === undefined
+                ? undefined
+                : deploymentReplayFingerprint(replayFingerprint);
+            if (deploymentFingerprint !== undefined &&
+                options.replayCache?.read &&
+                (await scenarioReplayMarkerExists(options.replayCache, deploymentFingerprint))) {
+                options.reporter.info?.(`-- Replayed passed deployment fixture ${scenario.label}: ${deploymentFingerprint}`);
+                continue;
+            }
+            try {
+                await runStep();
+            }
+            catch (error) {
+                throw new Error(`Generated deployment command failed for ${scenario.label}; command: ${step.display}. See the cause for the deployment mode, phase, command output, and retained container logs.`, { cause: error });
+            }
+            if (deploymentFingerprint !== undefined && options.replayCache?.write) {
+                await writeScenarioReplayMarker(options.replayCache, deploymentFingerprint, scenario);
+                options.reporter.info?.(`-- Stored passed deployment fixture replay marker for ${scenario.label}: ${deploymentFingerprint}`);
+            }
+            continue;
+        }
         if (step.id === "run-root-check" && requiresSerializedPlaywrightRootCheck) {
             await options.rootCheckLock.run(runStep);
-            continue;
         }
-        await runStep();
+        else {
+            await runStep();
+        }
+        if (step.id === "run-root-check" &&
+            options.replayCache?.write &&
+            replayFingerprint !== undefined) {
+            await writeScenarioReplayMarker(options.replayCache, replayFingerprint, scenario);
+            baseQualityGateMarkerWritten = true;
+            options.reporter.info?.(`-- Stored passed fixture replay marker for ${scenario.label}: ${replayFingerprint}`);
+        }
     }
-    if (options.replayCache?.write && replayFingerprint !== undefined) {
+    if (options.replayCache?.write &&
+        replayFingerprint !== undefined &&
+        !baseQualityGateMarkerWritten &&
+        !baseQualityGateReplayed) {
         await writeScenarioReplayMarker(options.replayCache, replayFingerprint, scenario);
         options.reporter.info?.(`-- Stored passed fixture replay marker for ${scenario.label}: ${replayFingerprint}`);
     }
@@ -482,15 +568,15 @@ async function runGeneratedScenarioInstallStep(step, scenario, options) {
         replayFingerprint = await hashGeneratedScenarioDirectory(scenario, step.cwd);
         if (options.replayCache.read &&
             (await scenarioReplayMarkerExists(options.replayCache, replayFingerprint))) {
-            options.reporter.info?.(`-- Replayed passed fixture ${scenario.label}: ${replayFingerprint}`);
-            return { fingerprint: replayFingerprint, replayed: true };
+            options.reporter.info?.(`-- Replayed passed base quality gate for ${scenario.label}: ${replayFingerprint}`);
+            return { fingerprint: replayFingerprint, baseQualityGateReplayed: true };
         }
     }
     await options.runCommand(step.command, ["fetch"], step.cwd, {
         logPrefix: scenario.label,
     });
     await options.runCommand(step.command, ["install", "--offline", "--frozen-lockfile"], step.cwd, { logPrefix: scenario.label });
-    return { fingerprint: replayFingerprint, replayed: false };
+    return { fingerprint: replayFingerprint, baseQualityGateReplayed: false };
 }
 async function checkGeneratedScenario(manifest, scenario, workspace, options) {
     options.reporter.info?.(`\n== ${scenario.label} ==`);

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

@@ -26,6 +26,13 @@ export type CheckComponent = {
     readonly kind: CheckComponentKind;
     readonly owner: ComponentOwner;
 };
+export type DeploymentCheckComponent = {
+    readonly kind: "deployment-image";
+    readonly owner: PackageBoundaryOwner;
+};
+export type DeploymentCheckEnvironmentNeed = {
+    readonly kind: "docker-engine";
+};
 export type FixComponent = {
     readonly kind: FixComponentKind;
     readonly owner: ComponentOwner;
@@ -33,6 +40,7 @@ export type FixComponent = {
 export type CheckPlan = {
     readonly components: CheckComponent[];
     readonly environmentNeeds: CheckEnvironmentNeed[];
+    readonly deploymentChecks?: DeploymentCheckComponent[] | undefined;
 };
 export type FixPlan = {
     readonly components: FixComponent[];
@@ -43,6 +51,10 @@ export declare function fixComponentTaskName(component: FixComponent): string;
 export declare function renderCheckLeafCommand(component: CheckComponent): string;
 export declare function renderFixLeafCommand(component: FixComponent): string;
 export declare function renderRootCheckCommand(plan: CheckPlan): string;
+export declare function deploymentCheckEnvironmentNeeds(check: DeploymentCheckComponent): DeploymentCheckEnvironmentNeed[];
+export declare function deploymentCheckTaskName(check: DeploymentCheckComponent): "check:deployment";
+export declare function renderDeploymentCheckLeafCommand(check: DeploymentCheckComponent): string;
+export declare function renderDeploymentCheckCommand(plan: Pick<CheckPlan, "deploymentChecks">): string;
 export declare function renderFixCommand(plan: FixPlan): string;
 export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed, options?: {
     readonly withDeps?: boolean;

package/node_modules/@ykdz/template-core/dist/module-graph.js

@@ -119,6 +119,24 @@ export function renderRootCheckCommand(plan) {
         "check:run",
     ]));
 }
+export function deploymentCheckEnvironmentNeeds(check) {
+    switch (check.kind) {
+        case "deployment-image":
+            return [{ kind: "docker-engine" }];
+    }
+}
+export function deploymentCheckTaskName(check) {
+    switch (check.kind) {
+        case "deployment-image":
+            return "check:deployment";
+    }
+}
+export function renderDeploymentCheckLeafCommand(check) {
+    return `pnpm --filter './${check.owner.path}' run ${deploymentCheckTaskName(check)}`;
+}
+export function renderDeploymentCheckCommand(plan) {
+    return uniqueTaskNames((plan.deploymentChecks ?? []).map(renderDeploymentCheckLeafCommand)).join(" && ");
+}
 export function renderFixCommand(plan) {
     return renderTurboRunCommand(uniqueTaskNames([
         ...plan.components.flatMap(fixComponentTaskNames),

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

@@ -4,10 +4,12 @@ packages:
 nodeLinker: hoisted
 
 catalog:
+  "@typescript/native": npm:typescript@^7.0.2
+  "@typescript/typescript6": ^6.0.2
   "@hono/node-server": ^2.0.6
   "@playwright/test": ^1.61.1
   "@tailwindcss/vite": ^4.3.2
-  "@types/node": ^24.0.0
+  "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
   "@vitejs/plugin-vue": ^6.0.7
   "@vikejs/hono": ^0.2.1
@@ -17,17 +19,18 @@ catalog:
   execa: ^9.6.1
   hono: ^4.12.27
   oxfmt: ^0.58.0
-  oxlint: ^1.72.0
+  oxlint: ^1.73.0
   oxlint-tsgolint: ^0.24.0
   pinia: ^3.0.4
+  srvx: ^0.11.21
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
   tsc-alias: ^1.8.17
-  tsx: ^4.22.4
+  tsx: ^4.23.0
   turbo: 2.10.2
   typescript: ^6.0.3
   valibot: ^1.4.2
-  vite: ^8.1.2
+  vite: ^8.1.4
   vike: ^0.4.260
   vike-vue: ^0.9.12
   vitest: ^4.1.10

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

@@ -2,7 +2,7 @@ import type { BuiltInPreset, PackageRole, PackageSourcePreset, ProjectBlueprint
 import type { GenerationContext } from "./generation-context.js";
 import { type CheckPlan, type FixPlan } from "./module-graph.js";
 import { type NextStepInstruction } from "./next-step-instructions.js";
-import type { CiDockerImageBuild, DependencyMaintenancePolicy } from "./project-github.js";
+import type { DependencyMaintenancePolicy } from "./project-github.js";
 import type { RenderOperation } from "./renderer.js";
 export type PresetPackageAdditionOptions = {
     readonly root: string;
@@ -35,7 +35,6 @@ export type PresetProjectionPlan = {
     readonly operations: readonly RenderOperation[];
     readonly checkPlan: CheckPlan;
     readonly fixPlan: FixPlan;
-    readonly ciDockerImageBuild?: CiDockerImageBuild | undefined;
     readonly dependencyMaintenancePolicy: DependencyMaintenancePolicy;
     readonly packageScripts: Record<string, string>;
     readonly capabilities: {

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

@@ -12,13 +12,6 @@ export type PnpmTaskLayer = {
     readonly installCommand: "pnpm install";
     readonly checkCommand: "pnpm run check";
 };
-export type CiDockerImageBuild = {
-    readonly dockerfile: string;
-    readonly targets: readonly {
-        readonly name: string;
-        readonly tag: string;
-    }[];
-};
 export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "rust-toolchain";
 export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
@@ -32,7 +25,6 @@ type ProjectCheckWorkflowOptions = {
     readonly capability?: CiCapability | undefined;
     readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
     readonly taskLayer?: PnpmTaskLayer | undefined;
-    readonly dockerImageBuild?: CiDockerImageBuild | undefined;
 };
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;

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

@@ -1,4 +1,4 @@
-import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { deploymentCheckEnvironmentNeeds, deploymentCheckTaskName, renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -16,6 +16,8 @@ export function projectCheckWorkflow(options) {
         ...options.environmentPreparation,
     };
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
+    const deploymentChecks = options.checkPlan.deploymentChecks ?? [];
+    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
     const lines = [
         `name: ${capability.workflowName}`,
         "",
@@ -34,15 +36,20 @@ export function projectCheckWorkflow(options) {
     if (environmentPreparation.nodeFromPackageMetadata) {
         lines.push("      - uses: actions/setup-node@v6", "        with:", "          node-version-file: package.json", "      - run: corepack enable");
     }
+    if (needsDocker) {
+        lines.push("      - uses: docker/setup-buildx-action@v3");
+    }
     if (environmentPreparation.rustToolchain) {
         lines.push("      - uses: dtolnay/rust-toolchain@stable", "        with:", "          components: rustfmt, clippy", "      - uses: Swatinem/rust-cache@v2");
     }
     lines.push(`      - run: ${taskLayer.installCommand}`);
     lines.push(...options.checkPlan.environmentNeeds.map((need) => `      - run: ${renderCiEnvironmentNeedCommand(need)}`));
-    lines.push(`      - run: ${taskLayer.checkCommand}`, "");
-    if (options.dockerImageBuild !== undefined) {
-        lines.push("  docker-image:", `    runs-on: ${capability.runner}`, "    steps:", "      - uses: actions/checkout@v7", "      - uses: docker/setup-buildx-action@v3", ...options.dockerImageBuild.targets.map((target) => `      - run: docker buildx build --load --file ${options.dockerImageBuild.dockerfile} --target ${target.name} --tag ${target.tag} .`), "");
+    lines.push(`      - run: ${taskLayer.checkCommand}`);
+    const deploymentCheck = deploymentChecks[0];
+    if (deploymentCheck !== undefined) {
+        lines.push(`      - run: pnpm run ${deploymentCheckTaskName(deploymentCheck)}`);
     }
+    lines.push("");
     return lines.join("\n");
 }
 export function projectDependabotConfig(policy) {