@ykdz/template 0.0.24 → 0.0.25

package/node_modules/@ykdz/template-builtin-presets/dist/src/foundation.d.ts

@@ -1,4 +1,4 @@
-import type { CheckComponent, CheckEnvironmentNeed, DeploymentCheckComponent, FixComponent } from "@ykdz/template-core/module-graph";
+import type { CheckEnvironmentNeed, DeploymentEnvironmentNeed } from "@ykdz/template-core/module-graph";
 import { type PackageContribution } from "@ykdz/template-core/package-contribution";
 import type { BuiltInPresetDefinition, GenerationContext } from "@ykdz/template-core/preset-definition";
 import { type ProjectBlueprintV2 } from "@ykdz/template-core/project-blueprint-v2";
@@ -23,10 +23,8 @@ export type GeneratedRepositoryPlan = {
         readonly toolchain: BuiltInGenerationContext["toolchain"];
     };
     readonly operations: readonly RenderOperation[];
-    readonly checks: readonly CheckComponent[];
-    readonly fixes: readonly FixComponent[];
     readonly environmentNeeds: readonly CheckEnvironmentNeed[];
-    readonly deploymentChecks: readonly DeploymentCheckComponent[];
+    readonly deploymentEnvironmentNeeds: readonly DeploymentEnvironmentNeed[];
     /** Structured manifests used to derive the generated Dependency Catalog. */
     readonly manifests: readonly Readonly<Record<string, unknown>>[];
     readonly dependencyCatalog: Readonly<Record<string, string>>;
@@ -42,7 +40,7 @@ export type BuiltInPresetTemplateSourceCheckContext = {
 /**
  * The Foundation persists the non-rendering half of every Package
  * Contribution with the Generated Repository.  Package Addition cannot infer
- * check, fix, deployment, or maintenance semantics from a package name (or
+ * fix, deployment, or maintenance semantics from a package name (or
  * from a lossy subset of scripts), so this is the durable topology it reads.
  */
 /** Resolve an owned source handle for diagnostics and source checks. */

package/node_modules/@ykdz/template-builtin-presets/dist/src/foundation.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { collectGeneratedManifestCatalogReferences, selectTemplateDependencyCatalogEntries, } from "@ykdz/template-core/dependency-catalog";
 import { browserTestToolLayer } from "@ykdz/template-core/devcontainer";
 import { editorCustomizationForCapabilities, loadEditorCustomizationDeclarations, } from "@ykdz/template-core/editor-customization";
-import { checkComponentTaskName, fixComponentTaskName, playwrightBrowserAssetsEnvironmentNeed, renderTurboRunCommand, rustToolchainEnvironmentNeed, shellCheckEnvironmentNeed, } from "@ykdz/template-core/module-graph";
+import { checkEnvironmentNeedFact, checkEnvironmentNeedFromFact, deploymentEnvironmentNeedFact, deploymentEnvironmentNeedFromFact, renderDeploymentCheckCommand, renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
 import { assertPackageContribution, } from "@ykdz/template-core/package-contribution";
 import { assertProjectBlueprintV2, validateProjectBlueprintV2 as validateCoreProjectBlueprintV2, } from "@ykdz/template-core/project-blueprint-v2";
 import { projectCheckWorkflowTemplateReplacements, projectDependabotTemplateReplacements, } from "@ykdz/template-core/project-github";
@@ -17,10 +17,11 @@ import { tsLibDefinition } from "./ts-lib/definition.js";
 import { vikeAppDefinition } from "./vike-app/definition.js";
 import { vueAppDefinition } from "./vue-app/definition.js";
 import { vueHonoAppDefinition } from "./vue-hono-app/definition.js";
+const environmentNeedsPath = ".template/environment-needs.json";
 /**
  * The Foundation persists the non-rendering half of every Package
  * Contribution with the Generated Repository.  Package Addition cannot infer
- * check, fix, deployment, or maintenance semantics from a package name (or
+ * fix, deployment, or maintenance semantics from a package name (or
  * from a lossy subset of scripts), so this is the durable topology it reads.
  */
 /** Resolve an owned source handle for diagnostics and source checks. */
@@ -110,10 +111,85 @@ export function createGenerationContext(options) {
         toolchain: options.toolchain,
     };
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function environmentNeedOwner(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (value.kind === "workspace-orchestration" && value.path === ".") {
+        return { kind: "workspace-orchestration", path: "." };
+    }
+    if (value.kind === "package-boundary" && typeof value.path === "string") {
+        return { kind: "package-boundary", path: value.path };
+    }
+    return undefined;
+}
+function persistedCheckEnvironmentNeedFact(value) {
+    if (!isRecord(value))
+        return undefined;
+    const owner = environmentNeedOwner(value.owner);
+    if (owner === undefined)
+        return undefined;
+    switch (value.kind) {
+        case "playwright-browser-assets":
+            return value.browser === "chromium"
+                ? { kind: value.kind, browser: value.browser, owner }
+                : undefined;
+        case "shellcheck-command":
+            return { kind: value.kind, owner };
+        case "rust-toolchain":
+            return value.toolchain === "stable"
+                ? { kind: value.kind, toolchain: value.toolchain, owner }
+                : undefined;
+        default:
+            return undefined;
+    }
+}
+function readPersistedEnvironmentNeeds(targetDir) {
+    const filePath = path.join(targetDir, environmentNeedsPath);
+    if (!existsSync(filePath)) {
+        throw new Error(`Package Addition requires explicit Check Environment Need facts: ${environmentNeedsPath} is missing`);
+    }
+    let value;
+    try {
+        value = JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Package Addition requires valid Check Environment Need facts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(value) ||
+        value.schemaVersion !== 1 ||
+        !Array.isArray(value.check) ||
+        !Array.isArray(value.deployment)) {
+        throw new Error(`Package Addition requires valid Check Environment Need facts in ${environmentNeedsPath}`);
+    }
+    const check = value.check.map(persistedCheckEnvironmentNeedFact);
+    if (check.some((fact) => fact === undefined)) {
+        throw new Error(`Package Addition requires supported Check Environment Need facts in ${environmentNeedsPath}`);
+    }
+    if (value.deployment.some((fact) => !isRecord(fact) || fact.kind !== "docker-engine")) {
+        throw new Error(`Package Addition requires supported deployment Environment Need facts in ${environmentNeedsPath}`);
+    }
+    return {
+        check: check.map(checkEnvironmentNeedFromFact),
+        deployment: value.deployment.map((fact) => deploymentEnvironmentNeedFromFact(fact)),
+    };
+}
+function uniqueEnvironmentNeeds(needs) {
+    const seen = new Set();
+    return needs.filter((need) => {
+        const key = JSON.stringify(need);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 /**
- * Package Addition reconstructs generic current facts from the Blueprint
- * topology and each package's real manifest/configuration.  A second durable
- * Contribution database would drift from the generated repository.
+ * Package Addition reconstructs generic current facts from the Blueprint,
+ * manifest truth, and explicit persisted Environment Need facts. Environment
+ * preparation is never derived from task script text.
  */
 function existingPackageContribution(options) {
     const packageRoot = path.join(options.context.targetDir, options.definition.path);
@@ -129,15 +205,10 @@ function existingPackageContribution(options) {
         throw new Error(`Package Addition requires manifest truth for ${options.definition.path}: expected name ${options.definition.name}`);
     }
     const record = manifest;
-    const scripts = typeof record.scripts === "object" && record.scripts !== null
-        ? record.scripts
-        : {};
-    const owner = {
-        kind: "package-boundary",
-        path: options.definition.path,
-    };
     const dependencyMaintenance = existingDependencyMaintenancePolicy(options.context.targetDir);
-    const rust = existsSync(path.join(packageRoot, "Cargo.toml"));
+    const environmentNeeds = options.environmentNeeds.filter((need) => need.owner.kind === "package-boundary" &&
+        need.owner.path === options.definition.path);
+    const rust = environmentNeeds.some((need) => need.kind === "rust-toolchain");
     const editorRecommendationsPath = path.join(options.context.targetDir, ".vscode/extensions.json");
     const editorRecommendations = existsSync(editorRecommendationsPath)
         ? JSON.parse(readFileSync(editorRecommendationsPath, "utf8")).recommendations
@@ -157,32 +228,6 @@ function existingPackageContribution(options) {
                 ? ["vitest"]
                 : []),
         ];
-    const checks = rust
-        ? [
-            { kind: "rustfmt-check", owner },
-            { kind: "cargo-clippy", owner },
-            { kind: "cargo-test", owner },
-        ]
-        : [
-            ...(scripts["typecheck:run"] === undefined
-                ? []
-                : [{ kind: "typescript-typecheck", owner }]),
-            ...(scripts["lint:run"] === undefined
-                ? []
-                : [{ kind: "oxc-lint", owner }]),
-            ...(scripts["format:check:run"] === undefined
-                ? []
-                : [{ kind: "oxc-format-check", owner }]),
-            ...(scripts["build:run"] === undefined
-                ? []
-                : [{ kind: "build", owner }]),
-            ...(scripts["test:run"] === undefined
-                ? []
-                : [{ kind: "unit-test", owner }]),
-            ...(scripts["test:e2e:run"] === undefined
-                ? []
-                : [{ kind: "e2e-test", owner }]),
-        ];
     return {
         definition: options.definition,
         manifest: record,
@@ -195,34 +240,7 @@ function existingPackageContribution(options) {
                 : {},
         },
         operations: [],
-        checks,
-        fixes: rust
-            ? [{ kind: "rustfmt-write", owner }]
-            : [
-                ...(scripts["format:write:run"] === undefined
-                    ? []
-                    : [{ kind: "oxc-format-write", owner }]),
-                ...(scripts["lint:fix:run"] === undefined
-                    ? []
-                    : [{ kind: "oxc-lint-fix", owner }]),
-            ],
-        environmentNeeds: [
-            ...(rust ? [rustToolchainEnvironmentNeed(owner)] : []),
-            ...(scripts["test:e2e:run"] === undefined
-                ? []
-                : [
-                    playwrightBrowserAssetsEnvironmentNeed({
-                        browser: "chromium",
-                        owner,
-                    }),
-                ]),
-            ...(Object.values(scripts).some((script) => typeof script === "string" && script.includes("shellcheck"))
-                ? [shellCheckEnvironmentNeed(owner)]
-                : []),
-        ],
-        ...(scripts["check:deployment"] === undefined
-            ? {}
-            : { deploymentChecks: [{ kind: "deployment-image", owner }] }),
+        environmentNeeds,
         foundation: {
             toolchains: rust
                 ? { rust: { toolchain: "stable", components: ["rustfmt", "clippy"] } }
@@ -287,38 +305,6 @@ function existingDependencyMaintenancePolicy(targetDir) {
         interval: "weekly",
     };
 }
-function unique(values) {
-    return [...new Set(values)];
-}
-function rootCheckCommand(checks) {
-    const rootTasks = unique(checks
-        .filter((check) => check.owner.kind === "workspace-orchestration")
-        .map(checkComponentTaskName));
-    const packageChecks = checks.filter((check) => check.owner.kind === "package-boundary");
-    const packageTasks = unique(packageChecks.map(checkComponentTaskName));
-    const packageFilters = unique(packageChecks.map((check) => `--filter './${check.owner.path}'`));
-    return [
-        "pnpm run check:boundaries",
-        ...rootTasks.map((task) => `pnpm run ${task}`),
-        ...(packageTasks.length === 0
-            ? []
-            : [renderTurboRunCommand(packageTasks, packageFilters)]),
-    ].join(" && ");
-}
-function rootFixCommand(fixes) {
-    const rootTasks = unique(fixes
-        .filter((fix) => fix.owner.kind === "workspace-orchestration")
-        .map(fixComponentTaskName));
-    const packageFixes = fixes.filter((fix) => fix.owner.kind === "package-boundary");
-    const packageTasks = unique(packageFixes.map(fixComponentTaskName));
-    const packageFilters = unique(packageFixes.map((fix) => `--filter './${fix.owner.path}'`));
-    return [
-        ...rootTasks.map((task) => `pnpm run ${task}`),
-        ...(packageTasks.length === 0
-            ? []
-            : [renderTurboRunCommand(packageTasks, packageFilters)]),
-    ].join(" && ");
-}
 function devcontainerDockerfileOperations(options) {
     const hasBrowserTests = options.environmentNeeds.some((need) => need.kind === "playwright-browser-assets");
     const hasShellChecks = options.environmentNeeds.some((need) => need.kind === "shellcheck-command");
@@ -366,40 +352,22 @@ function devcontainerDockerfileOperations(options) {
 }
 function foundationPlan(options) {
     assertProjectBlueprintV2(options.blueprint);
-    const foundationChecks = [
-        {
-            kind: "oxc-format-check",
-            owner: { kind: "workspace-orchestration", path: "." },
-        },
-        {
-            kind: "oxc-lint",
-            owner: { kind: "workspace-orchestration", path: "." },
-        },
-        {
-            kind: "typescript-typecheck",
-            owner: { kind: "workspace-orchestration", path: "." },
-        },
-    ];
-    const foundationFixes = [
-        {
-            kind: "oxc-format-write",
-            owner: { kind: "workspace-orchestration", path: "." },
-        },
-        {
-            kind: "oxc-lint-fix",
-            owner: { kind: "workspace-orchestration", path: "." },
-        },
-    ];
-    const checks = [
-        ...foundationChecks,
-        ...options.contributions.flatMap((item) => item.checks),
-    ];
-    const fixes = [
-        ...foundationFixes,
-        ...options.contributions.flatMap((item) => item.fixes),
-    ];
-    const environmentNeeds = options.contributions.flatMap((item) => item.environmentNeeds);
-    const deploymentChecks = options.contributions.flatMap((item) => item.deploymentChecks ?? []);
+    const environmentNeeds = uniqueEnvironmentNeeds(options.contributions.flatMap((item) => item.environmentNeeds));
+    const deploymentEnvironmentNeeds = uniqueEnvironmentNeeds([
+        ...(options.existingDeploymentEnvironmentNeeds ?? []),
+        ...options.contributions.flatMap((item) => item.deploymentEnvironmentNeeds ?? []),
+    ]);
+    const persistedEnvironmentNeeds = {
+        schemaVersion: 1,
+        check: environmentNeeds.map(checkEnvironmentNeedFact),
+        deployment: deploymentEnvironmentNeeds.map(deploymentEnvironmentNeedFact),
+    };
+    const hasDeploymentTask = options.contributions.some((contribution) => {
+        const scripts = contribution.manifest.scripts;
+        return (typeof scripts === "object" &&
+            scripts !== null &&
+            typeof scripts.deployment === "string");
+    });
     const packagePaths = options.contributions.map((contribution) => contribution.definition.path);
     if (new Set(packagePaths).size !== packagePaths.length)
         throw new Error("Package Contributions must have unique Package Paths");
@@ -414,9 +382,15 @@ function foundationPlan(options) {
         throw new Error("Foundation requires one coordinated Rust toolchain");
     }
     const workspacePackageGlobs = [
+        "apps/*",
+        "packages/*",
         ...new Set([
-            ...options.blueprint.packages.map((definition) => `${definition.path.split("/")[0]}/*`),
-            ...options.contributions.flatMap((contribution) => contribution.foundation.workspacePackageGlobs ?? []),
+            ...options.blueprint.packages
+                .map((definition) => `${definition.path.split("/")[0]}/*`)
+                .filter((glob) => glob !== "apps/*" && glob !== "packages/*"),
+            ...options.contributions
+                .flatMap((contribution) => contribution.foundation.workspacePackageGlobs ?? [])
+                .filter((glob) => glob !== "apps/*" && glob !== "packages/*"),
         ]),
     ];
     const editorCustomization = editorCustomizationForCapabilities(options.contributions.flatMap((contribution) => contribution.foundation.editorCapabilities), loadEditorCustomizationDeclarations(resolveTemplateSource(templateSources.editorCustomization, "capabilities.json")));
@@ -434,22 +408,17 @@ function foundationPlan(options) {
         private: true,
         type: "module",
         scripts: {
-            check: rootCheckCommand(checks),
-            "check:boundaries": "turbo boundaries --no-color",
-            ...(deploymentChecks.length === 0
-                ? {}
-                : {
-                    "check:deployment": deploymentChecks
-                        .map((check) => `pnpm --filter './${check.owner.path}' run check:deployment`)
-                        .join(" && "),
-                }),
-            fix: rootFixCommand(fixes),
-            "format:check:run": "oxfmt --list-different --config oxfmt.config.ts .",
-            "format:write:run": "oxfmt --write --config oxfmt.config.ts .",
-            "lint:run": "oxlint --quiet --format=unix --config oxlint.config.ts .",
-            "lint:fix:run": "oxlint --format=unix --config oxlint.config.ts . --fix",
-            typecheck: "pnpm run typecheck:run",
-            "typecheck:run": "tsc -p tsconfig.json --noEmit --pretty false",
+            check: renderRootCheckCommand(),
+            boundaries: "node scripts/check-boundaries.ts",
+            ...(hasDeploymentTask
+                ? { "check:deployment": renderDeploymentCheckCommand() }
+                : {}),
+            fix: renderFixCommand(),
+            "format:check": "node scripts/run-root-owned-task.ts format:check",
+            "format:write": "node scripts/run-root-owned-task.ts format:write",
+            lint: "node scripts/run-root-owned-task.ts lint",
+            "lint:fix": "node scripts/run-root-owned-task.ts lint:fix",
+            typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
         },
         devDependencies: {
             "@types/node": "catalog:",
@@ -467,7 +436,6 @@ function foundationPlan(options) {
         rootManifest,
     ]));
     const dependencyOverrides = {
-        "valibot>typescript": "-",
         ...(Object.hasOwn(dependencyCatalog, "vue") ||
             Object.hasOwn(dependencyCatalog, "pinia")
             ? vuePnpmDependencyOverrides
@@ -488,10 +456,16 @@ function foundationPlan(options) {
                     .toSorted(([left], [right]) => left.localeCompare(right))
                     .map(([name, version]) => `  ${JSON.stringify(name)}: ${String(version)}`)
                     .join("\n"),
-                DEPENDENCY_OVERRIDES: Object.entries(dependencyOverrides)
-                    .toSorted(([left], [right]) => left.localeCompare(right))
-                    .map(([dependency, version]) => `  ${JSON.stringify(dependency)}: ${JSON.stringify(version)}`)
-                    .join("\n"),
+                DEPENDENCY_OVERRIDES_SECTION: Object.keys(dependencyOverrides).length === 0
+                    ? ""
+                    : [
+                        "",
+                        "overrides:",
+                        ...Object.entries(dependencyOverrides)
+                            .toSorted(([left], [right]) => left.localeCompare(right))
+                            .map(([dependency, version]) => `  ${JSON.stringify(dependency)}: ${JSON.stringify(version)}`),
+                        "",
+                    ].join("\n"),
             },
             ...(options.mode === "addition" ? { overwrite: true } : {}),
         }
@@ -507,7 +481,9 @@ function foundationPlan(options) {
         from: ".github/workflows/check.dynamic.template",
         to: ".github/workflows/check.yml",
         replacements: projectCheckWorkflowTemplateReplacements({
-            checkPlan: { components: checks, environmentNeeds, deploymentChecks },
+            environment: { needs: environmentNeeds },
+            deploymentEnvironmentNeeds,
+            hasDeploymentTask,
         }),
         ...(options.mode === "addition" ? { overwrite: true } : {}),
     };
@@ -538,14 +514,20 @@ function foundationPlan(options) {
         {
             kind: "copyFile",
             source: templateSources.foundation,
-            from: ".pnpmfile.cts",
-            to: ".pnpmfile.cts",
+            from: "turbo.json",
+            to: "turbo.json",
         },
         {
             kind: "copyFile",
             source: templateSources.foundation,
-            from: "turbo.json",
-            to: "turbo.json",
+            from: "scripts/check-boundaries.ts",
+            to: "scripts/check-boundaries.ts",
+        },
+        {
+            kind: "copyFile",
+            source: templateSources.foundation,
+            from: "scripts/run-root-owned-task.ts",
+            to: "scripts/run-root-owned-task.ts",
         },
         {
             kind: "copyFile",
@@ -623,6 +605,22 @@ function foundationPlan(options) {
                             source: templateSources.foundation,
                             from: "rust/devcontainer/rust.Dockerfile",
                         },
+                        ...(environmentNeeds.some((need) => need.kind === "playwright-browser-assets")
+                            ? [
+                                {
+                                    source: templateSources.sharedDevcontainer,
+                                    from: "browser-test.Dockerfile",
+                                },
+                            ]
+                            : []),
+                        ...(environmentNeeds.some((need) => need.kind === "shellcheck-command")
+                            ? [
+                                {
+                                    source: templateSources.sharedDevcontainer,
+                                    from: "shellcheck.Dockerfile",
+                                },
+                            ]
+                            : []),
                     ],
                 },
             ]),
@@ -632,6 +630,11 @@ function foundationPlan(options) {
             to: ".template/blueprint.json",
             value: options.blueprint,
         },
+        {
+            kind: "writeJson",
+            to: environmentNeedsPath,
+            value: persistedEnvironmentNeeds,
+        },
         {
             kind: "writeJson",
             to: ".template/generation.json",
@@ -714,10 +717,8 @@ function foundationPlan(options) {
             toolchain: options.context.toolchain,
         },
         operations,
-        checks,
-        fixes,
         environmentNeeds,
-        deploymentChecks,
+        deploymentEnvironmentNeeds,
         manifests: [
             ...options.contributions.map((item) => item.manifest),
             rootManifest,
@@ -780,7 +781,12 @@ export function planGeneratedRepositoryPackageAddition(options) {
             : {}),
     };
     assertProjectBlueprintV2(blueprint);
-    const existingContributions = options.blueprint.packages.map((definition) => existingPackageContribution({ context: options.context, definition }));
+    const persistedEnvironmentNeeds = readPersistedEnvironmentNeeds(options.context.targetDir);
+    const existingContributions = options.blueprint.packages.map((definition) => existingPackageContribution({
+        context: options.context,
+        definition,
+        environmentNeeds: persistedEnvironmentNeeds.check,
+    }));
     if (existingContributions.length !== options.blueprint.packages.length ||
         existingContributions.some((existing) => !options.blueprint.packages.some((definition) => definition.path === existing.definition.path &&
             definition.name === existing.definition.name))) {
@@ -792,6 +798,7 @@ export function planGeneratedRepositoryPackageAddition(options) {
         blueprint,
         contributions: [...existingContributions, contribution],
         renderContributions: [contribution],
+        existingDeploymentEnvironmentNeeds: persistedEnvironmentNeeds.deployment,
         mode: "addition",
     });
 }

package/node_modules/@ykdz/template-builtin-presets/dist/src/rust-bin/definition.js

@@ -12,10 +12,10 @@ function cargoPackageName(projectName) {
 }
 function packageScripts() {
     return {
-        "format:check:run": "cargo fmt --all -- --check",
-        "format:write:run": "cargo fmt --all",
-        "lint:run": "cargo clippy --workspace --all-targets -- -D warnings",
-        "test:run": "cargo test --workspace",
+        "format:check": "cargo fmt --all -- --check",
+        "format:write": "cargo fmt --all",
+        lint: "cargo clippy --workspace --all-targets -- -D warnings",
+        test: "cargo test --workspace",
     };
 }
 function rustContribution(context) {
@@ -71,26 +71,6 @@ function rustContribution(context) {
             engines: { node: context.toolchain.nodeLtsMajor },
         },
         operations,
-        checks: [
-            {
-                kind: "rustfmt-check",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-            {
-                kind: "cargo-clippy",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-            {
-                kind: "cargo-test",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-        ],
-        fixes: [
-            {
-                kind: "rustfmt-write",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-        ],
         environmentNeeds: [
             rustToolchainEnvironmentNeed({
                 kind: "package-boundary",

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/vue.d.ts

@@ -1,4 +1,3 @@
-import { type CheckComponent, type FixComponent } from "@ykdz/template-core/module-graph";
 import type { PackageContribution } from "@ykdz/template-core/package-contribution";
 import type { GenerationContext } from "@ykdz/template-core/preset-definition";
 import type { PackageDefinition } from "@ykdz/template-core/project-blueprint-v2";
@@ -26,8 +25,6 @@ export declare function vueApplicationScripts(): Record<string, string>;
 export declare function sharedVueSourceOperations(packagePath: string): readonly RenderOperation[];
 /** Vike shares Vue's compiler runner, but owns its distinct Vike source tree. */
 export declare function vueTypecheckRunnerSourceOperation(packagePath: string): RenderOperation;
-export declare function vueApplicationChecks(packagePath: string): readonly CheckComponent[];
-export declare function vueApplicationFixes(packagePath: string): readonly FixComponent[];
 export declare function vueApplicationEnvironmentNeeds(packagePath: string): import("@ykdz/template-core/module-graph").PlaywrightBrowserAssetsEnvironmentNeed[];
 export declare function vueApplicationManifest(options: {
     readonly context: GenerationContext;

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/vue.js

@@ -1,4 +1,4 @@
-import { playwrightBrowserAssetsEnvironmentNeed, } from "@ykdz/template-core/module-graph";
+import { playwrightBrowserAssetsEnvironmentNeed } from "@ykdz/template-core/module-graph";
 import { templateSources } from "../template-sources.js";
 /** Vue's tooling peers need these repository policy overrides, never Core defaults. */
 export const vuePnpmDependencyOverrides = {
@@ -22,15 +22,15 @@ const sharedVueSourceFiles = [
 ];
 export function vueApplicationScripts() {
     return {
-        "build:run": "vite build",
+        build: "vite build",
         dev: "vite",
-        "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
-        "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
-        "lint:run": "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
-        "lint:fix:run": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
+        "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
+        "lint:fix": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
         preview: "vite preview",
-        "test:run": "vitest run --reporter=agent --silent=passed-only",
-        "test:e2e:run": "node scripts/run-playwright.ts",
+        test: "vitest run --reporter=agent --silent=passed-only",
+        "test:e2e": "node scripts/run-playwright.ts",
     };
 }
 export function sharedVueSourceOperations(packagePath) {
@@ -50,24 +50,6 @@ export function vueTypecheckRunnerSourceOperation(packagePath) {
         to: `${packagePath}/scripts/run-vue-tsc.ts`,
     };
 }
-export function vueApplicationChecks(packagePath) {
-    const owner = { kind: "package-boundary", path: packagePath };
-    return [
-        { kind: "typescript-typecheck", owner },
-        { kind: "oxc-lint", owner },
-        { kind: "oxc-format-check", owner },
-        { kind: "build", owner },
-        { kind: "unit-test", owner },
-        { kind: "e2e-test", owner },
-    ];
-}
-export function vueApplicationFixes(packagePath) {
-    const owner = { kind: "package-boundary", path: packagePath };
-    return [
-        { kind: "oxc-format-write", owner },
-        { kind: "oxc-lint-fix", owner },
-    ];
-}
 export function vueApplicationEnvironmentNeeds(packagePath) {
     return [
         playwrightBrowserAssetsEnvironmentNeed({

package/node_modules/@ykdz/template-builtin-presets/dist/src/ts-lib/definition.js

@@ -2,11 +2,11 @@ import { fileURLToPath } from "node:url";
 import { templateSources } from "../template-sources.js";
 function packageScripts() {
     return {
-        "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
-        "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
-        "lint:run": "oxlint --quiet --format=unix --config ../../oxlint.config.ts --ignore-pattern node_modules .",
-        "lint:fix:run": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
-        "typecheck:run": "tsc -p tsconfig.json --noEmit --pretty false",
+        "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --quiet --format=unix --config ../../oxlint.config.ts --ignore-pattern node_modules .",
+        "lint:fix": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
+        typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
     };
 }
 function libraryContribution(options) {
@@ -67,30 +67,6 @@ function libraryContribution(options) {
             scripts: packageScripts(),
         },
         operations,
-        checks: [
-            {
-                kind: "typescript-typecheck",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-            {
-                kind: "oxc-lint",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-            {
-                kind: "oxc-format-check",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-        ],
-        fixes: [
-            {
-                kind: "oxc-format-write",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-            {
-                kind: "oxc-lint-fix",
-                owner: { kind: "package-boundary", path: definition.path },
-            },
-        ],
         environmentNeeds: [],
         foundation: {
             toolchains: {},