@ykdz/template 0.0.23 → 0.0.25

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.app.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "paths": { "#/*": ["./*"] },
+    "skipLibCheck": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["test/**/*.ts", "vitest.config.ts"]
+}

package/node_modules/@ykdz/{template-builtin-source/templates/vue-app → template-builtin-presets/templates/vike-app/web}/turbo.json

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

package/node_modules/@ykdz/{template-builtin-source/templates/vike-app → template-builtin-presets/templates/vue-app}/.github/dependabot.yml

@@ -14,6 +14,11 @@ updates:
       - dependency-name: "@types/node"
         update-types:
           - version-update:semver-major
+      - dependency-name: "pnpm"
+        update-types:
+          - version-update:semver-major
+          - version-update:semver-minor
+          - version-update:semver-patch
   - package-ecosystem: github-actions
     directory: /
     schedule:
@@ -26,7 +31,3 @@ updates:
       - dependency-name: mcr.microsoft.com/devcontainers/typescript-node
         update-types:
           - version-update:semver-major
-  - package-ecosystem: docker
-    directory: /apps/web
-    schedule:
-      interval: weekly

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

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

package/node_modules/@ykdz/template-builtin-presets/templates/vue-app/typescript/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["run-vue-tsc.ts"]
+}

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/api/src/index.ts

@@ -0,0 +1,3 @@
+import type { app } from "./runtime.ts";
+
+export type AppType = typeof app;

package/node_modules/@ykdz/{template-builtin-source → template-builtin-presets}/templates/vue-hono-app/api/src/server.ts

@@ -1,6 +1,6 @@
 import { serve } from "@hono/node-server";
 
-import { app } from "./runtime.js";
+import { app } from "./runtime.ts";
 
 const port = Number(process.env.PORT ?? 3000);
 

package/node_modules/@ykdz/{template-builtin-source → template-builtin-presets}/templates/vue-hono-app/api/test/app.test.ts

@@ -1,4 +1,4 @@
-import { app } from "../src/runtime.js";
+import { app } from "../src/runtime.ts";
 
 describe("Hono API", () => {
   it("responds to the health route", async () => {

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/api/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/api/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "erasableSyntaxOnly": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUncheckedIndexedAccess": true,
+    "rewriteRelativeImportExtensions": true,
+    "skipLibCheck": false,
+    "strict": true,
+    "target": "es2023",
+    "types": ["node", "vitest/globals"],
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"]
+}

package/node_modules/@ykdz/{template-builtin-source → template-builtin-presets}/templates/vue-hono-app/api/turbo.json

@@ -2,7 +2,7 @@
   "extends": ["//"],
   "tags": ["app"],
   "tasks": {
-    "build:run": {
+    "build": {
       "outputs": ["dist/**"]
     }
   }

package/node_modules/@ykdz/{template-builtin-source → 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-source/templates/vike-app → 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.toml

@@ -6,7 +6,7 @@ publish = false
 
 [[bin]]
 name = "template-cargo-dependencies"
-path = "packages/builtin-source/templates/rust-bin/src/main.rs"
+path = "packages/builtin-presets/templates/rust-bin/src/main.rs"
 
 [dependencies]
 anyhow = "1.0.100"

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

@@ -4,6 +4,14 @@ export type GeneratedDependencyCatalogOptions = {
     readonly dependencies: readonly string[];
     readonly packages?: readonly string[];
     readonly allowBuilds?: Record<string, boolean>;
+    readonly dependencyLinker?: {
+        readonly kind: "isolated";
+    } | {
+        readonly kind: "hoisted";
+        readonly evidence: string;
+    };
+    readonly minimumReleaseAgeExclude?: readonly string[];
+    readonly overrides?: Readonly<Record<string, string>>;
 };
 export type GeneratedPackageManifestDependencies = {
     readonly dependencies?: Record<string, string>;

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

@@ -1,26 +1,31 @@
 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}`);
-        }
+const exactNpmPackageIdentityPattern = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+function assertMinimumReleaseAgeExclusions(exclusions) {
+    if (exclusions.some((dependency) => dependency.length === 0)) {
+        throw new Error("Dependency maturity exclusions must be non-empty");
+    }
+    if (new Set(exclusions).size !== exclusions.length) {
+        throw new Error("Dependency maturity exclusions must be unique");
+    }
+    const invalid = exclusions.find((dependency) => dependency.length > 214 ||
+        !exactNpmPackageIdentityPattern.test(dependency));
+    if (invalid !== undefined) {
+        throw new Error(`Dependency maturity exclusions must be exact npm package identities: ${JSON.stringify(invalid)}`);
     }
 }
 function templateRepositoryRoot() {
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
+        process.env.TEMPLATE_REPOSITORY_ROOT,
         moduleDir,
         path.resolve(moduleDir, ".."),
         path.resolve(moduleDir, "..", ".."),
         path.resolve(moduleDir, "..", "..", ".."),
     ];
-    return (candidates.find((candidate) => existsSync(path.join(candidate, "pnpm-workspace.yaml"))) ?? candidates[0]);
+    return (candidates.find((candidate) => candidate !== undefined &&
+        existsSync(path.join(candidate, "pnpm-workspace.yaml"))) ?? moduleDir);
 }
 function parseTemplateCatalogSection(workspaceYaml, sectionName) {
     const catalog = {};
@@ -162,7 +167,6 @@ 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:");
@@ -195,19 +199,51 @@ export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependen
     ].join("\n");
 }
 export function renderGeneratedPnpmWorkspaceYaml(options) {
-    assertGeneratedDependencyCatalogBoundary(options.dependencies);
+    assertMinimumReleaseAgeExclusions(options.minimumReleaseAgeExclude ?? []);
+    if (options.dependencyLinker?.kind === "hoisted" &&
+        (options.dependencyLinker.evidence.trim().length === 0 ||
+            options.dependencyLinker.evidence.includes("\n"))) {
+        throw new Error("Hoisted linking requires single-line compatibility evidence");
+    }
     const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
     const packages = options.packages ?? ["."];
+    const dependencyLinker = options.dependencyLinker?.kind ?? "isolated";
     const lines = [
         "packages:",
         ...packages.map((workspacePackage) => `  - ${workspacePackage}`),
         "",
+        ...(options.dependencyLinker?.kind === "hoisted"
+            ? [
+                `# Hoisted linker compatibility evidence: ${options.dependencyLinker.evidence}`,
+            ]
+            : []),
+        `nodeLinker: ${dependencyLinker}`,
+        "autoInstallPeers: false",
+        "resolvePeersFromWorkspaceRoot: false",
+        "injectWorkspacePackages: true",
+        "dedupeInjectedDeps: false",
+        "syncInjectedDepsAfterScripts:",
+        "  - build",
+        "minimumReleaseAge: 1440",
+        "minimumReleaseAgeStrict: true",
+        "",
     ];
+    if (options.minimumReleaseAgeExclude?.length) {
+        lines.push("minimumReleaseAgeExclude:", ...options.minimumReleaseAgeExclude
+            .toSorted()
+            .map((dependency) => `  - ${JSON.stringify(dependency)}`), "");
+    }
     if (options.allowBuilds) {
         lines.push("allowBuilds:", ...Object.entries(options.allowBuilds)
             .toSorted(([left], [right]) => left.localeCompare(right))
             .map(([dependency, allowed]) => `  ${dependency}: ${allowed}`), "");
     }
+    const overrides = options.overrides ?? {};
+    if (Object.keys(overrides).length > 0) {
+        lines.push("overrides:", ...Object.entries(overrides)
+            .toSorted(([left], [right]) => left.localeCompare(right))
+            .map(([dependency, version]) => `  ${JSON.stringify(dependency)}: ${JSON.stringify(version)}`), "");
+    }
     lines.push("catalog:", ...Object.entries(catalog).map(([dependency, version]) => `  ${renderCatalogKey(dependency)}: ${version}`), "");
     return lines.join("\n");
 }

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

@@ -1,4 +1,4 @@
-import type { WriteTextFromFragmentsOperation } from "./renderer.js";
+import type { TemplateSourceHandle, WriteTextFromFragmentsOperation } from "./renderer.ts";
 export type DevelopmentContainerNodePnpmLayer = {
     readonly kind: "node-pnpm";
     readonly nodeVersion: string;
@@ -12,9 +12,12 @@ export type DevelopmentContainerRustLayer = {
     readonly kind: "rust";
     readonly toolchain: string;
 };
-type DevelopmentContainerCapabilityLayer = DevelopmentContainerBrowserTestLayer | DevelopmentContainerRustLayer;
+export type DevelopmentContainerShellCheckLayer = {
+    readonly kind: "shellcheck";
+};
+type DevelopmentContainerCapabilityLayer = DevelopmentContainerBrowserTestLayer | DevelopmentContainerShellCheckLayer | DevelopmentContainerRustLayer;
 export type DevelopmentContainerDockerfileFragments = {
-    readonly sourceRoot: string;
+    readonly source: TemplateSourceHandle;
     readonly nodePnpm: {
         readonly from: string;
         readonly text: string;
@@ -23,6 +26,10 @@ export type DevelopmentContainerDockerfileFragments = {
         readonly from: string;
         readonly text: string;
     } | undefined;
+    readonly shellCheck?: {
+        readonly from: string;
+        readonly text: string;
+    } | undefined;
     readonly rust?: {
         readonly from: string;
         readonly text: string;
@@ -46,6 +53,7 @@ export declare function nodePnpmToolLayer(options: {
     readonly packageManagerPin: string;
 }): DevelopmentContainerNodePnpmLayer;
 export declare function browserTestToolLayer(): DevelopmentContainerBrowserTestLayer;
+export declare function shellCheckToolLayer(): DevelopmentContainerShellCheckLayer;
 export declare function rustToolLayer(options?: {
     readonly toolchain?: string;
 }): DevelopmentContainerRustLayer;

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

@@ -61,6 +61,9 @@ export function browserTestToolLayer() {
         playwrightCliPackage: `@playwright/test@${playwrightTestVersion}`,
     };
 }
+export function shellCheckToolLayer() {
+    return { kind: "shellcheck" };
+}
 export function rustToolLayer(options = {}) {
     return { kind: "rust", toolchain: options.toolchain ?? "stable" };
 }
@@ -80,6 +83,12 @@ function checkedNodePnpmDockerfile(options) {
                             name: "browser-test",
                             text: requireDockerfileFragment(options.dockerfileFragments, "browserTest").text,
                         };
+                    case "shellcheck":
+                        return {
+                            kind: "capability",
+                            name: "shellcheck",
+                            text: requireDockerfileFragment(options.dockerfileFragments, "shellCheck").text,
+                        };
                     case "rust":
                         return {
                             kind: "capability",
@@ -94,19 +103,24 @@ function checkedNodePnpmDockerfile(options) {
 function checkedNodePnpmDockerfileFragments(options) {
     return [
         {
-            sourceRoot: options.dockerfileFragments.sourceRoot,
+            source: options.dockerfileFragments.source,
             from: options.dockerfileFragments.nodePnpm.from,
         },
         ...(options.additionalLayers ?? []).map((layer) => {
             switch (layer.kind) {
                 case "browser-test":
                     return {
-                        sourceRoot: options.dockerfileFragments.sourceRoot,
+                        source: options.dockerfileFragments.source,
                         from: requireDockerfileFragment(options.dockerfileFragments, "browserTest").from,
                     };
+                case "shellcheck":
+                    return {
+                        source: options.dockerfileFragments.source,
+                        from: requireDockerfileFragment(options.dockerfileFragments, "shellCheck").from,
+                    };
                 case "rust":
                     return {
-                        sourceRoot: options.dockerfileFragments.sourceRoot,
+                        source: options.dockerfileFragments.source,
                         from: requireDockerfileFragment(options.dockerfileFragments, "rust")
                             .from,
                     };

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

@@ -1,21 +1,17 @@
-export type EditorCustomizationCapability = "oxc-format-lint" | "rust-tooling" | "tailwind" | "vue" | "vitest";
+/** Capability identities are supplied by the owning Built-in Presets policy. */
+export type EditorCustomizationCapability = string;
 export type EditorCustomization = {
     readonly extensions: readonly string[];
     readonly settings: Record<string, unknown>;
 };
-export type EditorCustomizationOptions = {
-    readonly oxcConfigPaths?: "nested" | {
-        readonly lint?: string;
-        readonly formatter?: string;
-    };
-};
 type CapabilityProjection = {
     readonly extensions: readonly string[];
     readonly settings: Record<string, unknown>;
 };
 export type EditorCustomizationDeclarations = {
-    readonly capabilities: Record<EditorCustomizationCapability, CapabilityProjection>;
+    readonly capabilityOrder: readonly EditorCustomizationCapability[];
+    readonly capabilities: Readonly<Record<EditorCustomizationCapability, CapabilityProjection>>;
 };
 export declare function loadEditorCustomizationDeclarations(resourcePath: string): EditorCustomizationDeclarations;
-export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], declarations: EditorCustomizationDeclarations, options?: EditorCustomizationOptions): EditorCustomization;
+export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], declarations: EditorCustomizationDeclarations): EditorCustomization;
 export {};

package/node_modules/@ykdz/template-core/dist/editor-customization.js

@@ -1,28 +1,12 @@
 import { readFileSync } from "node:fs";
 import * as v from "valibot";
-const capabilityOrder = [
-    "oxc-format-lint",
-    "vue",
-    "tailwind",
-    "rust-tooling",
-    "vitest",
-];
-const defaultOxcConfigPaths = {
-    formatter: "./oxfmt.config.ts",
-    lint: "./oxlint.config.ts",
-};
 const capabilityProjectionSchema = v.object({
     extensions: v.array(v.string()),
     settings: v.record(v.string(), v.unknown()),
 });
 const editorCustomizationDeclarationsSchema = v.object({
-    capabilities: v.object({
-        "oxc-format-lint": capabilityProjectionSchema,
-        vue: capabilityProjectionSchema,
-        tailwind: capabilityProjectionSchema,
-        "rust-tooling": capabilityProjectionSchema,
-        vitest: capabilityProjectionSchema,
-    }),
+    capabilityOrder: v.array(v.string()),
+    capabilities: v.record(v.string(), capabilityProjectionSchema),
 });
 function editorCustomizationDeclarationIssuePath(issue) {
     const segments = issue.path?.flatMap((item) => typeof item.key === "string" || typeof item.key === "number"
@@ -62,43 +46,21 @@ export function loadEditorCustomizationDeclarations(resourcePath) {
     }
     return result.output;
 }
-function oxcConfigPathSettings(configPaths) {
-    if (configPaths === "nested") {
-        return {};
-    }
-    const paths = {
-        ...defaultOxcConfigPaths,
-        ...configPaths,
-    };
-    return {
-        "oxc.configPath": paths.lint,
-        "oxc.fmt.configPath": paths.formatter,
-    };
-}
-function oxcProjection(options) {
-    const baseProjection = options.declarations.capabilities["oxc-format-lint"];
-    return {
-        extensions: baseProjection.extensions,
-        settings: {
-            ...baseProjection.settings,
-            ...oxcConfigPathSettings(options.editorOptions?.oxcConfigPaths),
-        },
-    };
-}
 function mergeSettings(base, patch) {
     return { ...base, ...patch };
 }
-export function editorCustomizationForCapabilities(capabilities, declarations, options) {
+export function editorCustomizationForCapabilities(capabilities, declarations) {
     const selected = new Set(capabilities);
     const extensions = new Set();
     let settings = {};
-    for (const capability of capabilityOrder) {
+    for (const capability of declarations.capabilityOrder) {
         if (!selected.has(capability)) {
             continue;
         }
-        const projection = capability === "oxc-format-lint"
-            ? oxcProjection({ declarations, editorOptions: options })
-            : declarations.capabilities[capability];
+        const projection = declarations.capabilities[capability];
+        if (projection === undefined) {
+            throw new Error(`Editor customization policy orders undeclared capability ${capability}`);
+        }
         for (const extension of projection.extensions) {
             extensions.add(extension);
         }

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

@@ -7,9 +7,7 @@ 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 CheckEnvironmentNeed = {
+export type PlaywrightBrowserAssetsEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";
     readonly browser: "chromium";
     readonly owner: ComponentOwner;
@@ -22,40 +20,72 @@ export type CheckEnvironmentNeed = {
         readonly machineVerifiable: boolean;
     };
 };
-export type CheckComponent = {
-    readonly kind: CheckComponentKind;
+export type ShellCheckEnvironmentNeed = {
+    readonly kind: "shellcheck-command";
     readonly owner: ComponentOwner;
+    readonly nextStep: {
+        readonly id: "install-shellcheck";
+        readonly label: "Install ShellCheck";
+        readonly command: "sudo";
+        readonly args: readonly string[];
+        readonly display: "sudo apt-get update && sudo apt-get install -y shellcheck";
+        readonly machineVerifiable: false;
+    };
 };
-export type DeploymentCheckComponent = {
-    readonly kind: "deployment-image";
-    readonly owner: PackageBoundaryOwner;
-};
-export type DeploymentCheckEnvironmentNeed = {
-    readonly kind: "docker-engine";
-};
-export type FixComponent = {
-    readonly kind: FixComponentKind;
+/** Rust task leaves require the maintained toolchain in local and CI plans. */
+export type RustToolchainEnvironmentNeed = {
+    readonly kind: "rust-toolchain";
     readonly owner: ComponentOwner;
+    readonly toolchain: "stable";
+    readonly nextStep: {
+        readonly id: "install-rust-toolchain";
+        readonly label: "Install Rust toolchain";
+        readonly command: "rustup";
+        readonly args: readonly string[];
+        readonly display: "rustup toolchain install stable --component rustfmt --component clippy";
+        readonly machineVerifiable: boolean;
+    };
 };
-export type CheckPlan = {
-    readonly components: CheckComponent[];
-    readonly environmentNeeds: CheckEnvironmentNeed[];
-    readonly deploymentChecks?: DeploymentCheckComponent[] | undefined;
-};
-export type FixPlan = {
-    readonly components: FixComponent[];
+/**
+ * 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 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;
@@ -66,4 +96,5 @@ export declare function playwrightBrowserAssetsEnvironmentNeed(options: {
     readonly id?: string;
     readonly label?: string;
     readonly machineVerifiable?: boolean;
-}): CheckEnvironmentNeed;
+}): PlaywrightBrowserAssetsEnvironmentNeed;
+export declare function shellCheckEnvironmentNeed(owner: ComponentOwner): ShellCheckEnvironmentNeed;