@ykdz/template 0.0.1 → 0.0.2

package/dist/rust-bin.js

@@ -1,6 +1,11 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { devcontainerNodeFeature } from "./devcontainer.js";
+import { assembleGenerationContext } from "./generation-context.js";
+import { planRustBinChecks, planRustBinFixes, renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
+import { projectPresetDependabotConfig, projectRustBinGithubCheckWorkflow } from "./project-github.js";
 import { renderNewProject } from "./renderer.js";
+import { resolveToolchainVersions } from "./toolchain-resolution.js";
 const features = [
     "root-check",
     "fix-command",
@@ -15,6 +20,13 @@ const generatedBy = {
     version: "0.0.0",
     command: "template init --preset rust-bin"
 };
+const rustBinBlueprint = {
+    schemaVersion: 1,
+    preset: "rust-bin",
+    packageManager: "pnpm",
+    projectKind: "single-package",
+    features: [...features],
+};
 function cargoPackageNameFromDir(targetDir) {
     const directoryName = path.basename(path.resolve(targetDir));
     const slug = directoryName
@@ -68,8 +80,46 @@ function cargoLock(projectName) {
         ""
     ].join("\n");
 }
-function operationsForRustBin(projectName) {
+export function projectRustBinPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planRustBinChecks()),
+        fix: renderFixCommand(planRustBinFixes()),
+    };
+}
+function packageJson(context, projectName) {
+    return {
+        name: projectName,
+        version: "0.0.0",
+        private: true,
+        scripts: projectRustBinPackageScripts(),
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
+function generationRecord(context) {
+    return {
+        ...generatedBy,
+        toolchain: {
+            nodeLtsMajor: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+            source: context.toolchain.source,
+        },
+    };
+}
+function operationsForRustBin(context, projectName) {
     return [
+        {
+            kind: "writeJson",
+            to: "package.json",
+            value: packageJson(context, projectName),
+        },
+        {
+            kind: "writeText",
+            to: "pnpm-workspace.yaml",
+            text: ["packages:", "  - .", ""].join("\n"),
+        },
         {
             kind: "writeText",
             to: "Cargo.toml",
@@ -95,41 +145,15 @@ function operationsForRustBin(projectName) {
             from: "src/main.rs",
             to: "src/main.rs"
         },
-        {
-            kind: "writeText",
-            to: "scripts/check",
-            text: [
-                "#!/usr/bin/env sh",
-                "set -eu",
-                "",
-                "echo cargo fmt --all -- --check",
-                "cargo fmt --all -- --check",
-                "echo cargo clippy --workspace --all-targets -- -D warnings",
-                "cargo clippy --workspace --all-targets -- -D warnings",
-                "echo cargo test --workspace",
-                "cargo test --workspace",
-                ""
-            ].join("\n")
-        },
-        {
-            kind: "setExecutable",
-            path: "scripts/check",
-            executable: true
-        },
         {
             kind: "writeJson",
             to: ".project-kit/blueprint.json",
-            value: {
-                schemaVersion: 1,
-                preset: "rust-bin",
-                projectKind: "single-package",
-                features
-            }
+            value: rustBinBlueprint
         },
         {
             kind: "writeJson",
             to: ".project-kit/generated-by.json",
-            value: generatedBy
+            value: generationRecord(context)
         },
         {
             kind: "writeJson",
@@ -137,12 +161,15 @@ function operationsForRustBin(projectName) {
             value: {
                 name: `${projectName} Rust development`,
                 image: "mcr.microsoft.com/devcontainers/rust:1",
+                features: devcontainerNodeFeature({
+                    nodeVersion: context.toolchain.nodeLtsMajor.value,
+                    packageManagerPin: context.toolchain.packageManagerPin.value,
+                }),
                 mounts: [
                     "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
                     "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
                     "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume"
                 ],
-                postCreateCommand: "rustup component add rustfmt clippy && cargo fetch",
                 customizations: {
                     vscode: {
                         extensions: ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
@@ -151,24 +178,31 @@ function operationsForRustBin(projectName) {
             }
         },
         {
-            kind: "copyFile",
-            from: ".github/workflows/check.yml",
+            kind: "writeText",
             to: ".github/workflows/check.yml",
+            text: projectRustBinGithubCheckWorkflow(),
         },
         {
-            kind: "copyFile",
-            from: ".github/dependabot.yml",
+            kind: "writeText",
             to: ".github/dependabot.yml",
+            text: projectPresetDependabotConfig("rust-bin"),
         }
     ];
 }
 function templateSourceRoot() {
     return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "rust-bin");
 }
-export async function initRustBinProject(targetDir) {
+export async function initRustBinProject(targetDir, options) {
+    const generationContext = options?.generationContext ??
+        assembleGenerationContext({
+            targetDir,
+            blueprint: rustBinBlueprint,
+            toolchain: await resolveToolchainVersions(),
+        });
+    const projectName = cargoPackageNameFromDir(targetDir);
     await renderNewProject({
         sourceRoot: templateSourceRoot(),
         targetRoot: targetDir,
-        operations: operationsForRustBin(cargoPackageNameFromDir(targetDir))
+        operations: operationsForRustBin(generationContext, projectName)
     });
 }

package/dist/toolchain-resolution.d.ts

@@ -0,0 +1,35 @@
+export type ToolchainResolutionSource = "online" | "bundled-fallback";
+export type NodeLtsMajor = {
+    readonly kind: "NodeLtsMajor";
+    readonly value: string;
+};
+export type PackageManagerPin = {
+    readonly kind: "PackageManagerPin";
+    readonly value: `pnpm@${string}`;
+};
+export type ResolvedToolchainVersions = {
+    readonly nodeLtsMajor: NodeLtsMajor;
+    readonly packageManagerPin: PackageManagerPin;
+    readonly source: ToolchainResolutionSource;
+    readonly diagnostics: string[];
+};
+export type ResolveToolchainVersionsOptions = {
+    readonly source?: ToolchainResolutionSource | "auto";
+    readonly fetchJson?: (url: string) => Promise<unknown>;
+    readonly nodeReleaseIndexUrl?: string;
+    readonly pnpmRegistryUrl?: string;
+};
+export declare const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
+export declare const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
+type OnlineToolchainResolutionContractOptions = {
+    readonly fetchJson?: (url: string) => Promise<unknown>;
+};
+export type OnlineToolchainResolutionContractResult = {
+    readonly nodeLtsMajor: NodeLtsMajor;
+    readonly packageManagerPin: PackageManagerPin;
+    readonly diagnostics: string[];
+};
+export declare function resolveToolchainVersions(options?: ResolveToolchainVersionsOptions): Promise<ResolvedToolchainVersions>;
+export declare function checkOnlineToolchainResolutionContract(options?: OnlineToolchainResolutionContractOptions): Promise<OnlineToolchainResolutionContractResult>;
+export {};
+//# sourceMappingURL=toolchain-resolution.d.ts.map

package/dist/toolchain-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolchain-resolution.d.ts","sourceRoot":"","sources":["../src/toolchain-resolution.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,QAAQ,GAAG,kBAAkB,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,GAAG,MAAM,CAAC;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF,eAAO,MAAM,mBAAmB,uCAAuC,CAAC;AACxE,eAAO,MAAM,eAAe,oCAAoC,CAAC;AAEjE,KAAK,wCAAwC,GAAG;IAC9C,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAmBF,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,yBAAyB,CAAC,CAiCpC;AAED,wBAAsB,sCAAsC,CAC1D,OAAO,GAAE,wCAA6C,GACrD,OAAO,CAAC,uCAAuC,CAAC,CAwBlD"}

package/dist/toolchain-resolution.js

@@ -0,0 +1,192 @@
+export const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
+export const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
+const bundledFallbackToolchain = {
+    nodeLtsMajor: nodeLtsMajor("22"),
+    packageManagerPin: packageManagerPin("10.0.0"),
+};
+export async function resolveToolchainVersions(options = {}) {
+    const source = options.source ?? "online";
+    if (source === "bundled-fallback") {
+        return fallbackResult([]);
+    }
+    try {
+        const fetchJson = options.fetchJson ?? fetchOfficialJson;
+        const nodeReleases = parseNodeReleaseIndex(await fetchJson(options.nodeReleaseIndexUrl ?? nodeReleaseIndexUrl));
+        const nodeMajor = latestLtsMajor(nodeReleases);
+        const pnpmMetadata = parsePnpmRegistryMetadata(await fetchJson(options.pnpmRegistryUrl ?? pnpmRegistryUrl));
+        const pnpmVersion = latestCompatiblePnpmVersion(pnpmMetadata, Number(nodeMajor.value));
+        return {
+            nodeLtsMajor: nodeMajor,
+            packageManagerPin: packageManagerPin(pnpmVersion),
+            source: "online",
+            diagnostics: [],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return fallbackResult([
+            `Using bundled fallback toolchain metadata because online resolution failed: ${message}`,
+        ]);
+    }
+}
+export async function checkOnlineToolchainResolutionContract(options = {}) {
+    const fetchJson = options.fetchJson ?? fetchOfficialJson;
+    const nodeMajor = await contractPhase("Node source parsing", async () => {
+        const nodeReleases = parseNodeReleaseIndex(await fetchJson(nodeReleaseIndexUrl));
+        return latestLtsMajor(nodeReleases);
+    });
+    const pnpmMetadata = await contractPhase("pnpm source parsing", async () => parsePnpmRegistryMetadata(await fetchJson(pnpmRegistryUrl)));
+    const pnpmVersion = await contractPhase("compatibility selection", async () => latestCompatiblePnpmVersion(pnpmMetadata, Number(nodeMajor.value)));
+    return {
+        nodeLtsMajor: nodeMajor,
+        packageManagerPin: packageManagerPin(pnpmVersion),
+        diagnostics: [
+            `Node source parsing succeeded; latest LTS major is ${nodeMajor.value}.`,
+            `pnpm source parsing succeeded; latest compatible pnpm release is ${pnpmVersion}.`,
+            `Compatibility selection succeeded for pnpm@${pnpmVersion} on Node ${nodeMajor.value}.`,
+        ],
+    };
+}
+async function contractPhase(phase, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Online toolchain resolution contract failed during ${phase}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+    }
+}
+function fallbackResult(diagnostics) {
+    return {
+        nodeLtsMajor: bundledFallbackToolchain.nodeLtsMajor,
+        packageManagerPin: bundledFallbackToolchain.packageManagerPin,
+        source: "bundled-fallback",
+        diagnostics,
+    };
+}
+function nodeLtsMajor(value) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`Invalid Node LTS major: ${value}`);
+    }
+    return { kind: "NodeLtsMajor", value };
+}
+function packageManagerPin(version) {
+    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error(`Invalid pnpm version: ${version}`);
+    }
+    return { kind: "PackageManagerPin", value: `pnpm@${version}` };
+}
+async function fetchOfficialJson(url) {
+    const response = await fetch(url, {
+        headers: { accept: "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`GET ${url} failed with HTTP ${response.status}`);
+    }
+    return response.json();
+}
+function parseNodeReleaseIndex(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("Node release index was not an array");
+    }
+    return value.map((entry) => {
+        if (!isRecord(entry)) {
+            throw new Error("Node release entry was not an object");
+        }
+        const version = entry.version;
+        const lts = entry.lts;
+        if (typeof version !== "string" ||
+            (typeof lts !== "string" && typeof lts !== "boolean")) {
+            throw new Error("Node release entry is missing version or lts");
+        }
+        return { version, lts };
+    });
+}
+function latestLtsMajor(releases) {
+    const majors = releases
+        .filter((release) => release.lts !== false)
+        .map((release) => release.version.match(/^v(\d+)\./)?.[1])
+        .filter((major) => major !== undefined)
+        .map(Number);
+    if (majors.length === 0) {
+        throw new Error("Node release index did not contain any LTS releases");
+    }
+    return nodeLtsMajor(String(Math.max(...majors)));
+}
+function parsePnpmRegistryMetadata(value) {
+    if (!isRecord(value) || !isRecord(value.versions)) {
+        throw new Error("pnpm registry metadata is missing versions");
+    }
+    const versions = {};
+    for (const [version, metadata] of Object.entries(value.versions)) {
+        if (!isRecord(metadata)) {
+            continue;
+        }
+        versions[version] = {
+            engines: isRecord(metadata.engines)
+                ? {
+                    node: typeof metadata.engines.node === "string"
+                        ? metadata.engines.node
+                        : undefined,
+                }
+                : undefined,
+        };
+    }
+    return { versions };
+}
+function latestCompatiblePnpmVersion(metadata, nodeMajor) {
+    const candidates = Object.entries(metadata.versions)
+        .filter(([version]) => /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+        .filter(([, packageMetadata]) => nodeSatisfiesRange(nodeMajor, packageMetadata.engines?.node))
+        .map(([version]) => version)
+        .sort(compareSemver);
+    const latest = candidates.at(-1);
+    if (!latest) {
+        throw new Error(`pnpm registry metadata did not contain a release compatible with Node ${nodeMajor}`);
+    }
+    return latest;
+}
+function nodeSatisfiesRange(nodeMajor, range) {
+    if (!range) {
+        return true;
+    }
+    return range
+        .split(/\s+/)
+        .filter(Boolean)
+        .every((comparator) => nodeSatisfiesComparator(nodeMajor, comparator));
+}
+function nodeSatisfiesComparator(nodeMajor, comparator) {
+    const match = comparator.match(/^(>=|>|<=|<|=)?(\d+)(?:\.\d+){0,2}$/);
+    if (!match) {
+        return false;
+    }
+    const operator = match[1] ?? "=";
+    const major = Number(match[2]);
+    if (operator === ">=") {
+        return nodeMajor >= major;
+    }
+    if (operator === ">") {
+        return nodeMajor > major;
+    }
+    if (operator === "<=") {
+        return nodeMajor <= major;
+    }
+    if (operator === "<") {
+        return nodeMajor < major;
+    }
+    return nodeMajor === major;
+}
+function compareSemver(left, right) {
+    const leftParts = left.split(/[.-]/).slice(0, 3).map(Number);
+    const rightParts = right.split(/[.-]/).slice(0, 3).map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return left.localeCompare(right);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/ts-lib.d.ts

@@ -1,2 +1,8 @@
-export declare function initTsLibProject(targetDir: string): Promise<void>;
+import { type GenerationContext } from "./generation-context.js";
+type InitTsLibProjectOptions = {
+    readonly generationContext?: GenerationContext;
+};
+export declare function projectTsLibPackageScripts(): Record<string, string>;
+export declare function initTsLibProject(targetDir: string, options?: InitTsLibProjectOptions): Promise<void>;
+export {};
 //# sourceMappingURL=ts-lib.d.ts.map

package/dist/ts-lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts-lib.d.ts","sourceRoot":"","sources":["../src/ts-lib.ts"],"names":[],"mappings":"AAoLA,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOvE"}
+{"version":3,"file":"ts-lib.d.ts","sourceRoot":"","sources":["../src/ts-lib.ts"],"names":[],"mappings":"AAIA,OAAO,EAA6B,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAiB5F,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CAChD,CAAC;AAmBF,wBAAgB,0BAA0B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWnE;AA4KD,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/ts-lib.js

@@ -1,17 +1,47 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { nodePnpmDevcontainer } from "./devcontainer.js";
+import { assembleGenerationContext } from "./generation-context.js";
+import { planTsLibChecks, planTsLibFixes, renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
+import { projectPresetDependabotConfig, projectTsLibGithubCheckWorkflow } from "./project-github.js";
 import { renderNewProject } from "./renderer.js";
+import { resolveToolchainVersions } from "./toolchain-resolution.js";
 const generatedBy = {
     packageName: "@ykdz/template",
     version: "0.0.0",
-    command: "template init --preset ts-lib"
+    command: "template init --preset ts-lib",
 };
-function projectNameFromDir(targetDir) {
-    return path.basename(path.resolve(targetDir));
+const tsLibBlueprint = {
+    schemaVersion: 1,
+    preset: "ts-lib",
+    packageManager: "pnpm",
+    projectKind: "single-package",
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+export function projectTsLibPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
+        check: renderRootCheckCommand(planTsLibChecks()),
+        fix: renderFixCommand(planTsLibFixes()),
+        "format:check": "oxfmt --check .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint . --deny-warnings",
+        "lint:fix": "oxlint . --fix --deny-warnings",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
 }
-function packageJson(projectName) {
+function packageJson(context) {
     return {
-        name: projectName,
+        name: context.projectName.value,
         version: "0.0.0",
         private: true,
         files: ["dist"],
@@ -19,39 +49,40 @@ function packageJson(projectName) {
         exports: {
             ".": {
                 default: "./dist/index.js",
-                types: "./dist/index.d.ts"
-            }
-        },
-        scripts: {
-            build: "tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
-            check: "pnpm run typecheck && pnpm run lint && pnpm run format:check",
-            fix: "pnpm run format:write && pnpm run lint:fix",
-            "format:check": "oxfmt --check .",
-            "format:write": "oxfmt --write .",
-            lint: "oxlint . --deny-warnings",
-            "lint:fix": "oxlint . --fix --deny-warnings",
-            typecheck: "tsc -p tsconfig.json --noEmit"
+                types: "./dist/index.d.ts",
+            },
         },
+        scripts: projectTsLibPackageScripts(),
         devDependencies: {
             "@types/node": "catalog:",
             oxfmt: "catalog:",
             oxlint: "catalog:",
             "tsc-alias": "catalog:",
-            typescript: "catalog:"
+            typescript: "catalog:",
         },
         engines: {
-            node: "22"
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
+function generationRecord(context) {
+    return {
+        ...generatedBy,
+        toolchain: {
+            nodeLtsMajor: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+            source: context.toolchain.source,
         },
-        packageManager: "pnpm@10.0.0"
     };
 }
-function operationsForTsLib(projectName) {
+function operationsForTsLib(context) {
     return [
         {
             kind: "writeJson",
             to: "package.json",
-            value: packageJson(projectName),
-            multilineArrays: ["files"]
+            value: packageJson(context),
+            multilineArrays: ["files"],
         },
         {
             kind: "writeText",
@@ -66,8 +97,8 @@ function operationsForTsLib(projectName) {
                 "  oxlint: ^1.71.0",
                 "  tsc-alias: ^1.8.17",
                 "  typescript: ^5.8.0",
-                ""
-            ].join("\n")
+                "",
+            ].join("\n"),
         },
         {
             kind: "writeJson",
@@ -81,38 +112,38 @@ function operationsForTsLib(projectName) {
                     noEmitOnError: true,
                     outDir: "dist",
                     paths: {
-                        "@/*": ["./src/*"]
+                        "@/*": ["./src/*"],
                     },
                     rootDir: "src",
                     skipLibCheck: false,
                     strict: true,
                     target: "ES2022",
-                    types: ["node"]
+                    types: ["node"],
                 },
-                include: ["src/**/*.ts"]
-            }
+                include: ["src/**/*.ts"],
+            },
         },
         {
             kind: "copyFile",
             sourceRoot: "sharedOxc",
             from: "node/oxlint.config.ts",
-            to: "oxlint.config.ts"
+            to: "oxlint.config.ts",
         },
         {
             kind: "copyFile",
             sourceRoot: "sharedOxc",
             from: "oxfmt.config.ts",
-            to: "oxfmt.config.ts"
+            to: "oxfmt.config.ts",
         },
         {
             kind: "writeText",
             to: ".gitignore",
-            text: ["node_modules", "dist", ".env", ""].join("\n")
+            text: ["node_modules", "dist", ".env", ""].join("\n"),
         },
         {
             kind: "copyFile",
             from: "src/index.ts",
-            to: "src/index.ts"
+            to: "src/index.ts",
         },
         {
             kind: "writeJson",
@@ -130,39 +161,35 @@ function operationsForTsLib(projectName) {
                     "fix-command",
                     "devcontainer",
                     "github-actions",
-                    "dependabot"
-                ]
-            }
+                    "dependabot",
+                ],
+            },
         },
         {
             kind: "writeJson",
             to: ".project-kit/generated-by.json",
-            value: generatedBy
+            value: generationRecord(context),
         },
         {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
-            value: {
-                name: `${projectName} development`,
-                image: "mcr.microsoft.com/devcontainers/typescript-node:22",
-                postCreateCommand: "corepack enable && pnpm install",
-                customizations: {
-                    vscode: {
-                        extensions: ["oxc.oxc-vscode"]
-                    }
-                }
-            }
+            value: nodePnpmDevcontainer({
+                name: `${context.projectName.value} development`,
+                nodeVersion: context.toolchain.nodeLtsMajor.value,
+                packageManagerPin: context.toolchain.packageManagerPin.value,
+                extensions: ["oxc.oxc-vscode"],
+            }),
         },
         {
-            kind: "copyFile",
-            from: ".github/workflows/check.yml",
+            kind: "writeText",
             to: ".github/workflows/check.yml",
+            text: projectTsLibGithubCheckWorkflow(),
         },
         {
-            kind: "copyFile",
-            from: ".github/dependabot.yml",
+            kind: "writeText",
             to: ".github/dependabot.yml",
-        }
+            text: projectPresetDependabotConfig("ts-lib"),
+        },
     ];
 }
 function templateSourceRoot() {
@@ -171,11 +198,17 @@ function templateSourceRoot() {
 function sharedOxcSourceRoot() {
     return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "shared", "oxc");
 }
-export async function initTsLibProject(targetDir) {
+export async function initTsLibProject(targetDir, options) {
+    const generationContext = options?.generationContext ??
+        assembleGenerationContext({
+            targetDir,
+            blueprint: tsLibBlueprint,
+            toolchain: await resolveToolchainVersions(),
+        });
     await renderNewProject({
         sourceRoot: templateSourceRoot(),
         sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         targetRoot: targetDir,
-        operations: operationsForTsLib(projectNameFromDir(targetDir))
+        operations: operationsForTsLib(generationContext),
     });
 }

package/dist/vue-app.d.ts

@@ -1,2 +1,3 @@
+export declare function projectVueAppPackageScripts(): Record<string, string>;
 export declare function initVueAppProject(targetDir: string): Promise<void>;
 //# sourceMappingURL=vue-app.d.ts.map

package/dist/vue-app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-app.d.ts","sourceRoot":"","sources":["../src/vue-app.ts"],"names":[],"mappings":"AA4SA,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOxE"}
+{"version":3,"file":"vue-app.d.ts","sourceRoot":"","sources":["../src/vue-app.ts"],"names":[],"mappings":"AAiCA,wBAAgB,2BAA2B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAepE;AAyQD,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOxE"}