@ykdz/template 0.0.24 → 0.0.25

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

@@ -7,8 +7,6 @@ export type WorkspaceOrchestrationOwner = {
     readonly path: ".";
 };
 export type ComponentOwner = PackageBoundaryOwner | WorkspaceOrchestrationOwner;
-export type CheckComponentKind = "typescript-typecheck" | "oxc-lint" | "oxc-format-check" | "build" | "unit-test" | "e2e-test" | "turbo-check" | "turbo-package-typecheck" | "turbo-package-build" | "turbo-package-test" | "turbo-package-e2e-test" | "turbo-package-check" | "rustfmt-check" | "cargo-clippy" | "cargo-test";
-export type FixComponentKind = "oxc-format-write" | "oxc-lint-fix" | "turbo-fix" | "turbo-package-fix" | "rustfmt-write";
 export type PlaywrightBrowserAssetsEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";
     readonly browser: "chromium";
@@ -34,7 +32,7 @@ export type ShellCheckEnvironmentNeed = {
         readonly machineVerifiable: false;
     };
 };
-/** Rust check components require the maintained toolchain in local and CI plans. */
+/** Rust task leaves require the maintained toolchain in local and CI plans. */
 export type RustToolchainEnvironmentNeed = {
     readonly kind: "rust-toolchain";
     readonly owner: ComponentOwner;
@@ -48,42 +46,46 @@ export type RustToolchainEnvironmentNeed = {
         readonly machineVerifiable: boolean;
     };
 };
-export type CheckEnvironmentNeed = PlaywrightBrowserAssetsEnvironmentNeed | ShellCheckEnvironmentNeed | RustToolchainEnvironmentNeed;
-export declare function rustToolchainEnvironmentNeed(owner: ComponentOwner): RustToolchainEnvironmentNeed;
-export type CheckComponent = {
-    readonly kind: CheckComponentKind;
-    readonly owner: ComponentOwner;
-};
-export type DeploymentCheckComponent = {
-    readonly kind: "deployment-image";
-    readonly owner: PackageBoundaryOwner;
-};
-export type DeploymentCheckEnvironmentNeed = {
+/**
+ * Docker is needed only by the focused deployment mode. It is deliberately
+ * outside ordinary Check Environment Needs, whose preparation and next steps
+ * apply to every generated-check scenario.
+ */
+export type DockerEngineEnvironmentNeed = {
     readonly kind: "docker-engine";
+    readonly preparation: {
+        readonly id: "verify-docker-engine";
+        readonly label: "Verify Docker engine";
+        readonly command: "docker";
+        readonly args: readonly ["version", "--format", "{{.Server.Version}}"];
+        readonly display: "docker version --format {{.Server.Version}}";
+        readonly machineVerifiable: true;
+    };
 };
-export type FixComponent = {
-    readonly kind: FixComponentKind;
-    readonly owner: ComponentOwner;
-};
-export type CheckPlan = {
-    readonly components: CheckComponent[];
-    readonly environmentNeeds: CheckEnvironmentNeed[];
-    readonly deploymentChecks?: DeploymentCheckComponent[] | undefined;
-};
-export type FixPlan = {
-    readonly components: FixComponent[];
-};
-export declare function renderTurboRunCommand(taskNames: readonly string[], args?: readonly string[]): string;
-export declare function checkComponentTaskName(component: CheckComponent): string;
-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 type CheckEnvironmentNeed = PlaywrightBrowserAssetsEnvironmentNeed | ShellCheckEnvironmentNeed | RustToolchainEnvironmentNeed;
+export type DeploymentEnvironmentNeed = DockerEngineEnvironmentNeed;
+/**
+ * The durable form of a Check Environment Need. It deliberately retains only
+ * the explicit preparation fact, never a task name or package execution list.
+ */
+export type CheckEnvironmentNeedFact = Pick<PlaywrightBrowserAssetsEnvironmentNeed, "kind" | "browser" | "owner"> | Pick<ShellCheckEnvironmentNeed, "kind" | "owner"> | Pick<RustToolchainEnvironmentNeed, "kind" | "owner" | "toolchain">;
+/** Deployment preparation is likewise durable without selecting an executing package. */
+export type DeploymentEnvironmentNeedFact = Pick<DockerEngineEnvironmentNeed, "kind">;
+export declare function checkEnvironmentNeedFact(need: CheckEnvironmentNeed): CheckEnvironmentNeedFact;
+export declare function checkEnvironmentNeedFromFact(fact: CheckEnvironmentNeedFact): CheckEnvironmentNeed;
+export declare function deploymentEnvironmentNeedFact(need: DeploymentEnvironmentNeed): DeploymentEnvironmentNeedFact;
+export declare function deploymentEnvironmentNeedFromFact(fact: DeploymentEnvironmentNeedFact): DeploymentEnvironmentNeed;
+export declare function rustToolchainEnvironmentNeed(owner: ComponentOwner): RustToolchainEnvironmentNeed;
+export declare function dockerEngineEnvironmentNeed(): DockerEngineEnvironmentNeed;
+export declare const qualityTaskVocabulary: readonly ["boundaries", "format:check", "lint", "typecheck", "build", "test", "test:e2e"];
+export declare function renderTurboRunCommand(taskNames: readonly string[], args?: readonly string[], options?: {
+    readonly outputLogs?: "errors-only" | "full";
+    readonly continueAfterFailure?: boolean;
+    readonly taskPrefix?: boolean;
+}): string;
+export declare function renderRootCheckCommand(): string;
+export declare function renderDeploymentCheckCommand(): string;
+export declare function renderFixCommand(): string;
 export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed, options?: {
     readonly withDeps?: boolean;
 }): string;

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

@@ -1,3 +1,39 @@
+export function checkEnvironmentNeedFact(need) {
+    switch (need.kind) {
+        case "playwright-browser-assets":
+            return { kind: need.kind, browser: need.browser, owner: need.owner };
+        case "shellcheck-command":
+            return { kind: need.kind, owner: need.owner };
+        case "rust-toolchain":
+            return {
+                kind: need.kind,
+                owner: need.owner,
+                toolchain: need.toolchain,
+            };
+    }
+}
+export function checkEnvironmentNeedFromFact(fact) {
+    switch (fact.kind) {
+        case "playwright-browser-assets":
+            return playwrightBrowserAssetsEnvironmentNeed({
+                browser: fact.browser,
+                owner: fact.owner,
+            });
+        case "shellcheck-command":
+            return shellCheckEnvironmentNeed(fact.owner);
+        case "rust-toolchain":
+            return rustToolchainEnvironmentNeed(fact.owner);
+    }
+}
+export function deploymentEnvironmentNeedFact(need) {
+    return { kind: need.kind };
+}
+export function deploymentEnvironmentNeedFromFact(fact) {
+    if (fact.kind !== "docker-engine") {
+        throw new Error("Unsupported Deployment Environment Need fact.");
+    }
+    return dockerEngineEnvironmentNeed();
+}
 export function rustToolchainEnvironmentNeed(owner) {
     return {
         kind: "rust-toolchain",
@@ -21,150 +57,56 @@ export function rustToolchainEnvironmentNeed(owner) {
         },
     };
 }
-function renderTurboPackageFilter(owner) {
-    if (owner.kind !== "package-boundary") {
-        throw new Error("Turbo package tasks require a Package Boundary owner.");
-    }
-    return `--filter './${owner.path}'`;
+export function dockerEngineEnvironmentNeed() {
+    return {
+        kind: "docker-engine",
+        preparation: {
+            id: "verify-docker-engine",
+            label: "Verify Docker engine",
+            command: "docker",
+            args: ["version", "--format", "{{.Server.Version}}"],
+            display: "docker version --format {{.Server.Version}}",
+            machineVerifiable: true,
+        },
+    };
 }
-const turboAgentOutputArgs = [
-    "--output-logs=errors-only",
-    "--log-order=grouped",
+export const qualityTaskVocabulary = [
+    "boundaries",
+    "format:check",
+    "lint",
+    "typecheck",
+    "build",
+    "test",
+    "test:e2e",
 ];
-export function renderTurboRunCommand(taskNames, args = []) {
-    return ["turbo run", ...taskNames, ...args, ...turboAgentOutputArgs].join(" ");
-}
-export function checkComponentTaskName(component) {
-    return checkComponentTaskNames(component)[0] ?? "check:run";
-}
-function checkComponentTaskNames(component) {
-    switch (component.kind) {
-        case "typescript-typecheck":
-        case "turbo-package-typecheck":
-            return ["typecheck:run"];
-        case "oxc-lint":
-        case "cargo-clippy":
-            return ["lint:run"];
-        case "oxc-format-check":
-        case "rustfmt-check":
-            return ["format:check:run"];
-        case "build":
-        case "turbo-package-build":
-            return ["build:run"];
-        case "unit-test":
-        case "cargo-test":
-        case "turbo-package-test":
-            return ["test:run"];
-        case "e2e-test":
-        case "turbo-package-e2e-test":
-            return ["test:e2e:run"];
-        case "turbo-check":
-        case "turbo-package-check":
-            return [
-                "format:check:run",
-                "lint:run",
-                "typecheck:run",
-                "build:run",
-                "test:run",
-                "test:e2e:run",
-            ];
-    }
-}
-export function fixComponentTaskName(component) {
-    return fixComponentTaskNames(component)[0] ?? "fix:run";
-}
-function fixComponentTaskNames(component) {
-    switch (component.kind) {
-        case "oxc-format-write":
-        case "rustfmt-write":
-            return ["format:write:run"];
-        case "oxc-lint-fix":
-            return ["lint:fix:run"];
-        case "turbo-fix":
-        case "turbo-package-fix":
-            return ["format:write:run", "lint:fix:run"];
-    }
-}
-function uniqueTaskNames(taskNames) {
-    return [...new Set(taskNames)];
-}
-export function renderCheckLeafCommand(component) {
-    switch (component.kind) {
-        case "typescript-typecheck":
-            return "pnpm run typecheck";
-        case "oxc-lint":
-            return "pnpm run lint";
-        case "oxc-format-check":
-            return "pnpm run format:check";
-        case "build":
-            return "pnpm run build";
-        case "unit-test":
-            return "pnpm run test";
-        case "e2e-test":
-            return "pnpm run test:e2e";
-        case "turbo-check":
-            return renderTurboRunCommand(["check"]);
-        case "turbo-package-typecheck":
-            return renderTurboRunCommand(["typecheck"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-build":
-            return renderTurboRunCommand(["build"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-test":
-            return renderTurboRunCommand(["test"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-e2e-test":
-            return renderTurboRunCommand(["test:e2e"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-check":
-            return renderTurboRunCommand(["check"], [renderTurboPackageFilter(component.owner)]);
-        case "rustfmt-check":
-            return "cargo fmt --all -- --check";
-        case "cargo-clippy":
-            return "cargo clippy --workspace --all-targets -- -D warnings";
-        case "cargo-test":
-            return "cargo test --workspace";
-    }
-}
-export function renderFixLeafCommand(component) {
-    switch (component.kind) {
-        case "oxc-format-write":
-            return "pnpm run format:write";
-        case "oxc-lint-fix":
-            return "pnpm run lint:fix";
-        case "turbo-fix":
-            return renderTurboRunCommand(["fix"]);
-        case "turbo-package-fix":
-            return renderTurboRunCommand(["fix"], [renderTurboPackageFilter(component.owner)]);
-        case "rustfmt-write":
-            return "cargo fmt --all";
-    }
-}
-export function renderRootCheckCommand(plan) {
-    return renderTurboRunCommand(uniqueTaskNames([
-        ...plan.components.flatMap(checkComponentTaskNames),
-        "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),
-        "fix:run",
-    ]));
+export function renderTurboRunCommand(taskNames, args = [], options = {}) {
+    return [
+        "turbo run",
+        ...taskNames,
+        ...args,
+        ...(options.continueAfterFailure
+            ? ["--continue=dependencies-successful"]
+            : []),
+        `--output-logs=${options.outputLogs ?? "errors-only"}`,
+        "--log-order=grouped",
+        ...(options.taskPrefix ? ["--log-prefix=task"] : []),
+    ].join(" ");
+}
+export function renderRootCheckCommand() {
+    return renderTurboRunCommand(qualityTaskVocabulary, [], {
+        continueAfterFailure: true,
+        taskPrefix: true,
+    });
+}
+export function renderDeploymentCheckCommand() {
+    return renderTurboRunCommand(["deployment"], [], { taskPrefix: true });
+}
+export function renderFixCommand() {
+    return renderTurboRunCommand(["lint:fix", "format:write"], [], {
+        continueAfterFailure: true,
+        outputLogs: "full",
+        taskPrefix: true,
+    });
 }
 function playwrightBrowserInstallArgs(need, options = {}) {
     const installArgs = [

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

@@ -1,5 +1,5 @@
 import type { EditorCustomizationCapability } from "./editor-customization.ts";
-import type { CheckComponent, CheckEnvironmentNeed, DeploymentCheckComponent, FixComponent } from "./module-graph.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";
@@ -31,11 +31,9 @@ export type PackageContribution = {
     readonly operations: readonly RenderOperation[];
     /** Typed requirements consumed by the Foundation for coordinated root outputs. */
     readonly foundation: FoundationContribution;
-    readonly checks: readonly CheckComponent[];
-    readonly fixes: readonly FixComponent[];
     readonly environmentNeeds: readonly CheckEnvironmentNeed[];
-    /** Deployment checks are package-owned and composed by the Foundation. */
-    readonly deploymentChecks?: readonly DeploymentCheckComponent[];
+    /** Requirements prepared only by a focused deployment entrypoint. */
+    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
 };
 export declare function assertPackageContribution(contribution: PackageContribution, provenance?: {
     readonly definitionName?: string;

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

@@ -1,14 +1,14 @@
+const operationPath = (operation) => {
+    if ("to" in operation)
+        return operation.to;
+    if ("path" in operation)
+        return operation.path;
+    return "";
+};
 export function assertPackageContribution(contribution, provenance = {}) {
     if (contribution.definition.name !== contribution.manifest.name) {
         throw new Error("Package Contribution manifest name must match its Package Definition");
     }
-    const operationPath = (operation) => {
-        if ("to" in operation)
-            return operation.to;
-        if ("path" in operation)
-            return operation.path;
-        return "";
-    };
     const outsideOperation = contribution.operations.find((operation) => !operationPath(operation).startsWith(`${contribution.definition.path}/`));
     if (outsideOperation) {
         const target = operationPath(outsideOperation);

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

@@ -11,7 +11,6 @@ dedupeInjectedDeps: false
 
 syncInjectedDepsAfterScripts:
   - build
-  - build:run
 
 minimumReleaseAge: 1440
 
@@ -19,7 +18,6 @@ minimumReleaseAgeStrict: true
 
 overrides:
   "pinia>typescript": "-"
-  "valibot>typescript": "-"
   "vue>typescript": "-"
 
 catalog:

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

@@ -1,4 +1,4 @@
-import { type CheckPlan } from "./module-graph.ts";
+import { type CheckEnvironmentNeed, type DeploymentEnvironmentNeed } from "./module-graph.ts";
 export type CiCapability = {
     readonly workflowName: "Check";
     readonly jobName: "check";
@@ -21,7 +21,11 @@ export type DependencyMaintenancePolicy = {
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
-    readonly checkPlan: CheckPlan;
+    readonly environment: {
+        readonly needs: readonly CheckEnvironmentNeed[];
+    };
+    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
+    readonly hasDeploymentTask?: boolean | undefined;
     readonly capability?: CiCapability | undefined;
     readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
     readonly taskLayer?: PnpmTaskLayer | undefined;
@@ -29,7 +33,11 @@ type ProjectCheckWorkflowOptions = {
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 /** Limited substitutions for the Foundation-owned workflow Template Source. */
 export declare function projectCheckWorkflowTemplateReplacements(options: {
-    readonly checkPlan: CheckPlan;
+    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;

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

@@ -1,4 +1,4 @@
-import { deploymentCheckEnvironmentNeeds, deploymentCheckTaskName, renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -16,10 +16,10 @@ export function projectCheckWorkflow(options) {
         ...options.environmentPreparation,
     };
     const requiresRustToolchain = environmentPreparation.rustToolchain ||
-        options.checkPlan.environmentNeeds.some((need) => need.kind === "rust-toolchain");
+        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
-    const deploymentChecks = options.checkPlan.deploymentChecks ?? [];
-    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
+    const hasDeploymentTask = options.hasDeploymentTask === true;
+    const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
     const lines = [
         `name: ${capability.workflowName}`,
         "",
@@ -32,42 +32,38 @@ export function projectCheckWorkflow(options) {
         "jobs:",
         `  ${capability.jobName}:`,
         `    runs-on: ${capability.runner}`,
-        ...(deploymentChecks.length === 0
-            ? []
-            : [
-                "    strategy:",
-                "      matrix:",
-                "        check: [root, deployment]",
-            ]),
+        ...(hasDeploymentTask
+            ? ["    strategy:", "      matrix:", "        check: [root, deployment]"]
+            : []),
         "    steps:",
         "      - uses: actions/checkout@v7",
     ];
     if (environmentPreparation.nodeFromPackageMetadata) {
         lines.push("      - uses: actions/setup-node@v6", "        with:", "          node-version-file: package.json", "      - run: corepack enable");
     }
-    if (needsDocker) {
+    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.checkPlan.environmentNeeds) {
-        if (need.kind === "rust-toolchain")
+    for (const need of options.environment.needs) {
+        if (need.kind === "rust-toolchain") {
             continue;
+        }
         checkEnvironmentLines.push(`      - run: ${renderCiEnvironmentNeedCommand(need)}`);
-        if (deploymentChecks.length > 0 && need.kind === "shellcheck-command") {
+        if (hasDeploymentTask && need.kind === "shellcheck-command") {
             checkEnvironmentLines.push("        if: matrix.check == 'root'");
         }
     }
     lines.push(...checkEnvironmentLines);
     lines.push(`      - run: ${taskLayer.checkCommand}`);
-    if (deploymentChecks.length > 0) {
+    if (hasDeploymentTask) {
         lines.push("        if: matrix.check == 'root'");
     }
-    const deploymentCheck = deploymentChecks[0];
-    if (deploymentCheck !== undefined) {
-        lines.push(`      - run: pnpm run ${deploymentCheckTaskName(deploymentCheck)}`, "        if: matrix.check == 'deployment'");
+    if (hasDeploymentTask) {
+        lines.push("      - run: pnpm run check:deployment", "        if: matrix.check == 'deployment'");
     }
     lines.push("");
     return lines.join("\n");
@@ -83,15 +79,14 @@ function rustCiPreparationLines() {
 /** Limited substitutions for the Foundation-owned workflow Template Source. */
 export function projectCheckWorkflowTemplateReplacements(options) {
     const requiresRustToolchain = options.environmentPreparation?.rustToolchain === true ||
-        options.checkPlan.environmentNeeds.some((need) => need.kind === "rust-toolchain");
-    const deploymentChecks = options.checkPlan.deploymentChecks ?? [];
-    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
-    const deploymentCheck = deploymentChecks[0];
-    const environmentSteps = options.checkPlan.environmentNeeds
+        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)}`,
-        ...(deploymentChecks.length > 0 && need.kind === "shellcheck-command"
+        ...(hasDeploymentTask && need.kind === "shellcheck-command"
             ? ["        if: matrix.check == 'root'"]
             : []),
     ].join("\n"));
@@ -100,18 +95,18 @@ export function projectCheckWorkflowTemplateReplacements(options) {
             ? `\n${rustCiPreparationLines().join("\n")}`
             : "",
         CHECK_ENVIRONMENT_PREPARATION: environmentSteps.length === 0 ? "" : `\n${environmentSteps.join("\n")}`,
-        DEPLOYMENT_MATRIX: deploymentChecks.length === 0
-            ? ""
-            : "\n    strategy:\n      matrix:\n        check: [root, deployment]",
-        DEPLOYMENT_DOCKER_PREPARATION: needsDocker
+        DEPLOYMENT_MATRIX: hasDeploymentTask
+            ? "\n    strategy:\n      matrix:\n        check: [root, deployment]"
+            : "",
+        DEPLOYMENT_DOCKER_PREPARATION: hasDeploymentTask && needsDocker
             ? "\n      - uses: docker/setup-buildx-action@v3\n        if: matrix.check == 'deployment'"
             : "",
-        ROOT_CHECK_CONDITION: deploymentChecks.length === 0
-            ? ""
-            : "\n        if: matrix.check == 'root'",
-        DEPLOYMENT_CHECK: deploymentCheck === undefined
-            ? ""
-            : `\n      - run: pnpm run ${deploymentCheckTaskName(deploymentCheck)}\n        if: matrix.check == 'deployment'`,
+        ROOT_CHECK_CONDITION: hasDeploymentTask
+            ? "\n        if: matrix.check == 'root'"
+            : "",
+        DEPLOYMENT_CHECK: hasDeploymentTask
+            ? "\n      - run: pnpm run check:deployment\n        if: matrix.check == 'deployment'"
+            : "",
     };
 }
 export function projectDependabotConfig(policy) {

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

@@ -4,7 +4,7 @@ export type ExplicitProjectLinkPlan = {
     readonly manifestDependenciesByPackagePath: ReadonlyMap<string, Readonly<Record<string, "workspace:*">>>;
     /**
      * Build ordering follows the same explicit package relationships as manifest
-     * dependencies.  Turbo resolves ^build:run through the derived workspace
+     * dependencies. Turbo resolves ^build through the derived workspace
      * dependency rather than through Preset or framework vocabulary.
      */
     readonly hasBuildOrdering: boolean;

package/package.json

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

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/.pnpmfile.cts

@@ -1,14 +0,0 @@
-const typeOnlyPeerOwners = new Set(["valibot"]);
-
-function readPackage(pkg: {
-  name?: string;
-  peerDependencies?: Record<string, string>;
-  peerDependenciesMeta?: Record<string, unknown>;
-}) {
-  if (!pkg.name || !typeOnlyPeerOwners.has(pkg.name)) return pkg;
-  delete pkg.peerDependencies?.typescript;
-  delete pkg.peerDependenciesMeta?.typescript;
-  return pkg;
-}
-
-export default { hooks: { readPackage } };