@ykdz/template 0.0.24 → 0.0.26

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/playwright.config.ts

@@ -24,7 +24,7 @@ export default defineConfig({
   },
   webServer: [
     {
-      command: `pnpm --dir ../api run build:run && PORT=${apiPort} pnpm --dir ../api run start`,
+      command: `pnpm --dir ../api run build && PORT=${apiPort} pnpm --dir ../api run start`,
       url: apiHealthUrl,
       reuseExistingServer: false,
     },

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/turbo.json

@@ -2,10 +2,10 @@
   "extends": ["//"],
   "tags": ["app"],
   "tasks": {
-    "build:run": {
+    "build": {
       "outputs": ["dist/**"]
     },
-    "test:e2e:run": {
+    "test:e2e": {
       "cache": false
     }
   }

package/node_modules/@ykdz/template-core/dist/Cargo.lock

@@ -4,9 +4,9 @@ version = 4
 
 [[package]]
 name = "anyhow"
-version = "1.0.103"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
 
 [[package]]
 name = "template-cargo-dependencies"

package/node_modules/@ykdz/template-core/dist/Cargo.toml

@@ -9,4 +9,4 @@ name = "template-cargo-dependencies"
 path = "packages/builtin-presets/templates/rust-bin/src/main.rs"
 
 [dependencies]
-anyhow = "1.0.100"
+anyhow = "1.0.104"

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

@@ -12,7 +12,6 @@ export type GeneratedDependencyCatalogOptions = {
     };
     readonly minimumReleaseAgeExclude?: readonly string[];
     readonly overrides?: Readonly<Record<string, string>>;
-    readonly pnpmfile?: string;
 };
 export type GeneratedPackageManifestDependencies = {
     readonly dependencies?: Record<string, string>;

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

@@ -218,15 +218,12 @@ export function renderGeneratedPnpmWorkspaceYaml(options) {
             ]
             : []),
         `nodeLinker: ${dependencyLinker}`,
-        ...(options.pnpmfile === undefined
-            ? []
-            : [`pnpmfile: ${options.pnpmfile}`]),
         "autoInstallPeers: false",
         "resolvePeersFromWorkspaceRoot: false",
         "injectWorkspacePackages: true",
         "dedupeInjectedDeps: false",
         "syncInjectedDepsAfterScripts:",
-        "  - build:run",
+        "  - build",
         "minimumReleaseAge: 1440",
         "minimumReleaseAgeStrict: true",
         "",
@@ -241,10 +238,7 @@ export function renderGeneratedPnpmWorkspaceYaml(options) {
             .toSorted(([left], [right]) => left.localeCompare(right))
             .map(([dependency, allowed]) => `  ${dependency}: ${allowed}`), "");
     }
-    const overrides = {
-        "valibot>typescript": "-",
-        ...options.overrides,
-    };
+    const overrides = options.overrides ?? {};
     if (Object.keys(overrides).length > 0) {
         lines.push("overrides:", ...Object.entries(overrides)
             .toSorted(([left], [right]) => left.localeCompare(right))

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:
@@ -28,24 +26,24 @@ catalog:
   "@tailwindcss/vite": ^4.3.2
   "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
-  "@vitejs/plugin-vue": ^6.0.7
+  "@vitejs/plugin-vue": ^6.0.8
   "@vikejs/hono": ^0.2.1
   "@vue/tsconfig": ^0.9.1
   drizzle-kit: 1.0.0-rc.4
   drizzle-orm: 1.0.0-rc.4
-  execa: ^9.6.1
-  hono: ^4.12.27
+  execa: ^10.0.0
+  hono: ^4.12.31
   oxfmt: ^0.58.0
   oxlint: ^1.73.0
   oxlint-tsgolint: ^0.24.0
   semver: ^7.8.5
   "@types/semver": ^7.7.1
   pinia: ^3.0.4
-  srvx: ^0.11.21
+  srvx: ^0.12.1
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
   tsc-alias: ^1.8.17
-  turbo: 2.10.2
+  turbo: 2.10.5
   typescript: npm:@typescript/typescript6@^6.0.2
   typescript-7: npm:typescript@^7.0.2
   valibot: ^1.4.2

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;