@ykdz/template 0.0.23 → 0.0.24

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-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,15 @@ 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>>;
+    readonly pnpmfile?: 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,57 @@ 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}`,
+        ...(options.pnpmfile === undefined
+            ? []
+            : [`pnpmfile: ${options.pnpmfile}`]),
+        "autoInstallPeers: false",
+        "resolvePeersFromWorkspaceRoot: false",
+        "injectWorkspacePackages: true",
+        "dedupeInjectedDeps: false",
+        "syncInjectedDepsAfterScripts:",
+        "  - build:run",
+        "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 = {
+        "valibot>typescript": "-",
+        ...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

@@ -9,7 +9,7 @@ export type WorkspaceOrchestrationOwner = {
 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,6 +22,34 @@ export type CheckEnvironmentNeed = {
         readonly machineVerifiable: boolean;
     };
 };
+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;
+    };
+};
+/** Rust check components 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 CheckEnvironmentNeed = PlaywrightBrowserAssetsEnvironmentNeed | ShellCheckEnvironmentNeed | RustToolchainEnvironmentNeed;
+export declare function rustToolchainEnvironmentNeed(owner: ComponentOwner): RustToolchainEnvironmentNeed;
 export type CheckComponent = {
     readonly kind: CheckComponentKind;
     readonly owner: ComponentOwner;
@@ -66,4 +94,5 @@ export declare function playwrightBrowserAssetsEnvironmentNeed(options: {
     readonly id?: string;
     readonly label?: string;
     readonly machineVerifiable?: boolean;
-}): CheckEnvironmentNeed;
+}): PlaywrightBrowserAssetsEnvironmentNeed;
+export declare function shellCheckEnvironmentNeed(owner: ComponentOwner): ShellCheckEnvironmentNeed;

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

@@ -1,3 +1,26 @@
+export function rustToolchainEnvironmentNeed(owner) {
+    return {
+        kind: "rust-toolchain",
+        owner,
+        toolchain: "stable",
+        nextStep: {
+            id: "install-rust-toolchain",
+            label: "Install Rust toolchain",
+            command: "rustup",
+            args: [
+                "toolchain",
+                "install",
+                "stable",
+                "--component",
+                "rustfmt",
+                "--component",
+                "clippy",
+            ],
+            display: "rustup toolchain install stable --component rustfmt --component clippy",
+            machineVerifiable: false,
+        },
+    };
+}
 function renderTurboPackageFilter(owner) {
     if (owner.kind !== "package-boundary") {
         throw new Error("Turbo package tasks require a Package Boundary owner.");
@@ -157,6 +180,9 @@ function playwrightBrowserInstallArgs(need, options = {}) {
     return installArgs;
 }
 export function renderPlaywrightBrowserInstallCommand(need, options = {}) {
+    if (need.kind !== "playwright-browser-assets") {
+        throw new Error("Playwright install requires browser assets.");
+    }
     return ["pnpm", ...playwrightBrowserInstallArgs(need, options)].join(" ");
 }
 export function playwrightBrowserAssetsNextStepDescriptor(owner) {
@@ -188,3 +214,17 @@ export function playwrightBrowserAssetsEnvironmentNeed(options) {
         },
     };
 }
+export function shellCheckEnvironmentNeed(owner) {
+    return {
+        kind: "shellcheck-command",
+        owner,
+        nextStep: {
+            id: "install-shellcheck",
+            label: "Install ShellCheck",
+            command: "sudo",
+            args: ["sh", "-c", "apt-get update && apt-get install -y shellcheck"],
+            display: "sudo apt-get update && sudo apt-get install -y shellcheck",
+            machineVerifiable: false,
+        },
+    };
+}

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

@@ -0,0 +1,43 @@
+import type { EditorCustomizationCapability } from "./editor-customization.ts";
+import type { CheckComponent, CheckEnvironmentNeed, DeploymentCheckComponent, FixComponent } 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";
+export type FoundationContribution = {
+    /** Toolchains the Foundation must install and project into coordinated root files. */
+    readonly toolchains: {
+        readonly rust?: {
+            readonly toolchain: string;
+            readonly components: readonly ("rustfmt" | "clippy")[];
+        };
+    };
+    /** Editor capabilities the Foundation must project into its coordinated editor files. */
+    readonly editorCapabilities: readonly EditorCustomizationCapability[];
+    /** Ecosystems and paths whose maintenance belongs in the coordinated root policy. */
+    readonly dependencyMaintenance: DependencyMaintenancePolicy;
+    /** Workspace membership patterns contributed by package boundaries. */
+    readonly workspacePackageGlobs?: readonly string[];
+    /** Dependency Catalog entries required by package-owned manifests. */
+    readonly dependencyCatalog?: Readonly<Record<string, string>>;
+};
+/** A preset-agnostic package-sized part of a Generated Repository Plan. */
+export type PackageContribution = {
+    readonly definition: PackageDefinition;
+    readonly manifest: Readonly<Record<string, unknown>>;
+    readonly exposure: {
+        readonly exports: Readonly<Record<string, unknown>>;
+        readonly imports: Readonly<Record<string, unknown>>;
+    };
+    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[];
+};
+export declare function assertPackageContribution(contribution: PackageContribution, provenance?: {
+    readonly definitionName?: string;
+    readonly planner?: string;
+}): PackageContribution;

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

@@ -0,0 +1,24 @@
+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);
+        const rule = target.includes("/")
+            ? "Package Contribution may not write a sibling Package Boundary"
+            : "Package Contribution may not write a coordinated root output";
+        const owner = provenance.definitionName === undefined
+            ? ""
+            : `${provenance.definitionName}: ${provenance.planner ?? "Package Contribution"} `;
+        throw new Error(`${owner}${rule}; ${contribution.definition.path} attempted ${target}`);
+    }
+    return contribution;
+}

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

@@ -1,11 +1,28 @@
 packages:
   - packages/*
 
-nodeLinker: hoisted
+nodeLinker: isolated
+
+autoInstallPeers: false
+
+injectWorkspacePackages: true
+
+dedupeInjectedDeps: false
+
+syncInjectedDepsAfterScripts:
+  - build
+  - build:run
+
+minimumReleaseAge: 1440
+
+minimumReleaseAgeStrict: true
+
+overrides:
+  "pinia>typescript": "-"
+  "valibot>typescript": "-"
+  "vue>typescript": "-"
 
 catalog:
-  "@typescript/native": npm:typescript@^7.0.2
-  "@typescript/typescript6": ^6.0.2
   "@hono/node-server": ^2.0.6
   "@playwright/test": ^1.61.1
   "@tailwindcss/vite": ^4.3.2
@@ -21,14 +38,16 @@ catalog:
   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
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
   tsc-alias: ^1.8.17
-  tsx: ^4.23.0
   turbo: 2.10.2
-  typescript: ^6.0.3
+  typescript: npm:@typescript/typescript6@^6.0.2
+  typescript-7: npm:typescript@^7.0.2
   valibot: ^1.4.2
   vite: ^8.1.4
   vike: ^0.4.260
@@ -40,6 +59,3 @@ catalog:
 
 allowBuilds:
   esbuild: true
-
-onlyBuiltDependencies:
-  - esbuild

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

@@ -0,0 +1,42 @@
+import type { PackageContribution } from "./package-contribution.ts";
+import type { ProjectBlueprintV2 } from "./project-blueprint-v2.ts";
+import type { TemplateSourceHandle } from "./renderer.ts";
+/** Stable, preset-agnostic input supplied after toolchain resolution. */
+export type GenerationContext = {
+    readonly targetDir: string;
+    readonly projectName: string;
+    readonly scope: string;
+    readonly toolchain: {
+        readonly nodeLtsMajor: string;
+        readonly packageManagerPin: string;
+    };
+};
+/** A side-effect-free Built-in Preset planner. */
+export type BuiltInPresetDefinition = {
+    readonly metadata: {
+        readonly name: string;
+        readonly title: string;
+        readonly description: string;
+    };
+    /** The Definition owns its Preset-local Self-Checking Template Source. */
+    readonly source: TemplateSourceHandle;
+    /** The owned planner source inspected by the Template Boundary Check. */
+    readonly plannerSourceFile: string;
+    blueprint(context: GenerationContext): ProjectBlueprintV2;
+    planInitialization(context: GenerationContext): PackageContribution;
+    /**
+     * Multi-package Definitions expose their complete owned topology directly,
+     * while single-package Definitions keep the compact tracer interface.
+     */
+    planInitializationContributions?(context: GenerationContext): readonly PackageContribution[];
+    /** Package layout is Preset-owned even when callers omit --path. */
+    defaultPackagePath?(options: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+    }): string;
+    planPackageAddition?(options: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+        readonly packagePath: string;
+    }): PackageContribution;
+};

package/node_modules/@ykdz/template-core/dist/preset-definition.js

@@ -0,0 +1 @@
+export {};