@ykdz/template 0.0.2 → 0.0.4

package/dist/{next-step-instructions.js → src/next-step-instructions.js}

@@ -1,5 +1,4 @@
-import path from "node:path";
-import { planPresetChecks, renderPlaywrightBrowserInstallCommand } from "./module-graph.js";
+import { renderPlaywrightBrowserInstallCommand } from "./module-graph.js";
 function rootCheckInstruction() {
     return {
         id: "run-root-check",
@@ -12,6 +11,40 @@ function rootCheckInstruction() {
         machineVerifiable: true,
     };
 }
+function optionalGitInstructions() {
+    return [
+        {
+            id: "optional-git-init",
+            label: "Optional: initialize git",
+            kind: "command",
+            command: "git",
+            args: ["init"],
+            cwd: "",
+            display: "git init",
+            machineVerifiable: false,
+        },
+        {
+            id: "optional-git-add",
+            label: "Optional: stage files",
+            kind: "command",
+            command: "git",
+            args: ["add", "."],
+            cwd: "",
+            display: "git add .",
+            machineVerifiable: false,
+        },
+        {
+            id: "optional-git-commit",
+            label: "Optional: create your first commit",
+            kind: "command",
+            command: "git",
+            args: ["commit", "-m", "Initial commit"],
+            cwd: "",
+            display: 'git commit -m "Initial commit"',
+            machineVerifiable: false,
+        },
+    ];
+}
 function installDependenciesInstruction() {
     return {
         id: "install-dependencies",
@@ -36,12 +69,8 @@ function fixInstruction() {
         machineVerifiable: true,
     };
 }
-function checkEnvironmentInstructions(preset) {
-    const checkPlan = planPresetChecks(preset);
-    if (!checkPlan) {
-        return [];
-    }
-    return checkPlan.environmentNeeds.map((need) => {
+function checkEnvironmentInstructions(plan) {
+    return plan.checkPlan.environmentNeeds.map((need) => {
         const display = renderPlaywrightBrowserInstallCommand(need);
         const [command, ...args] = display.split(" ");
         return {
@@ -60,24 +89,21 @@ function checkEnvironmentInstructions(preset) {
         };
     });
 }
-function presetSpecificInstructions(preset) {
-    if (preset === "ts-lib" ||
-        preset === "hono-api" ||
-        preset === "vue-app" ||
-        preset === "vue-hono-app" ||
-        preset === "rust-bin") {
-        return [
-            installDependenciesInstruction(),
-            fixInstruction(),
-            ...checkEnvironmentInstructions(preset),
-            rootCheckInstruction(),
-        ];
+function projectionInstructions(plan) {
+    const steps = [installDependenciesInstruction()];
+    if (plan.capabilities.fixCommand) {
+        steps.push(fixInstruction());
+    }
+    steps.push(...checkEnvironmentInstructions(plan));
+    if (plan.capabilities.rootCheck) {
+        steps.push(rootCheckInstruction());
     }
-    return [installDependenciesInstruction(), rootCheckInstruction()];
+    steps.push(...optionalGitInstructions());
+    return steps;
 }
 export function planNextStepInstructions(options) {
-    const targetDir = path.resolve(options.targetDir);
-    const commandSteps = presetSpecificInstructions(options.preset).map((step) => ({
+    const targetDir = options.targetDir;
+    const commandSteps = projectionInstructions(options.projectionPlan).map((step) => ({
         ...step,
         cwd: targetDir,
     }));
@@ -92,7 +118,6 @@ export function planNextStepInstructions(options) {
         machineVerifiable: false,
     };
     return Object.freeze({
-        preset: options.preset,
         targetDir,
         steps: Object.freeze([navigationStep, ...commandSteps].map((step) => Object.freeze(step))),
     });

package/dist/{package-addition.d.ts → src/package-addition.d.ts}

@@ -2,6 +2,6 @@ export type AddPackageOptions = {
     cwd: string;
     preset: string;
     name: string;
+    path?: string;
 };
 export declare function addPackage(options: AddPackageOptions): Promise<void>;
-//# sourceMappingURL=package-addition.d.ts.map

package/dist/src/package-addition.js

@@ -0,0 +1,343 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { findBuiltInPresetProjection } from "../templates/registry.js";
+import { validateProjectBlueprint, } from "./declarations.js";
+import { collectGeneratedManifestCatalogReferences, pnpmWorkspaceYamlWithCatalogDependencies, } from "./dependency-catalog.js";
+import { renderProject } from "./renderer.js";
+function projectNameFromBlueprint(blueprint) {
+    const firstPackage = blueprint.packages?.[0];
+    const match = firstPackage?.name.match(/^@([^/]+)\//);
+    if (!match) {
+        throw new Error("Cannot infer workspace package scope from the stored Project Blueprint");
+    }
+    return match[1];
+}
+function assertSafePackageLeaf(name) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new Error("--name must be a lowercase package leaf name using letters, numbers, and hyphens");
+    }
+}
+const reservedPackagePathCollections = new Set([
+    ".devcontainer",
+    ".git",
+    ".github",
+    ".template",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "out",
+    "target",
+]);
+function assertSafePackagePathSegment(packagePath, segment) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(segment)) {
+        throw new Error(`Package Path ${packagePath} must use safe path segments with lowercase letters, numbers, and hyphens`);
+    }
+}
+function validateExplicitPackagePath(packagePath) {
+    if (path.isAbsolute(packagePath)) {
+        throw new Error(`Package Path ${packagePath} must be relative`);
+    }
+    if (packagePath !== packagePath.trim()) {
+        throw new Error(`Package Path ${packagePath} must not contain whitespace`);
+    }
+    if (packagePath === ".." ||
+        packagePath.startsWith("../") ||
+        packagePath.endsWith("/..") ||
+        packagePath.includes("/../")) {
+        throw new Error(`Package Path ${packagePath} must not escape the workspace`);
+    }
+    const normalized = path.posix.normalize(packagePath);
+    if (normalized !== packagePath || packagePath.includes("\\")) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    const segments = packagePath.split("/");
+    if (segments.length !== 2) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    const [collection, packageDirectory] = segments;
+    if (!collection || !packageDirectory) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    if (reservedPackagePathCollections.has(collection)) {
+        throw new Error(`Package Path ${packagePath} uses reserved collection ${collection}`);
+    }
+    assertSafePackagePathSegment(packagePath, collection);
+    assertSafePackagePathSegment(packagePath, packageDirectory);
+    if (reservedPackagePathCollections.has(packageDirectory)) {
+        throw new Error(`Package Path ${packagePath} uses reserved package directory ${packageDirectory}`);
+    }
+    return packagePath;
+}
+function defaultPackagePathForPreset(preset, packageLeafName) {
+    return preset === "ts-lib"
+        ? `packages/${packageLeafName}`
+        : `apps/${packageLeafName}`;
+}
+function assertNoPackageConflict(blueprint, packageName, packagePath) {
+    const existingByName = blueprint.packages?.find((pkg) => pkg.name === packageName);
+    if (existingByName) {
+        throw new Error(`Package Path ${packagePath} conflicts with existing package ${existingByName.name} at ${existingByName.path}`);
+    }
+    const existingByPath = blueprint.packages?.find((pkg) => pkg.path === packagePath);
+    if (existingByPath) {
+        throw new Error(`Package Path ${packagePath} conflicts with existing package ${existingByPath.name} at ${existingByPath.path}`);
+    }
+}
+async function readJson(filePath) {
+    return JSON.parse(await readFile(filePath, "utf8"));
+}
+async function writeJson(filePath, value) {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+async function assertMissingPackagePath(packagePath, targetPath) {
+    try {
+        await stat(targetPath);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    throw new Error(`Package Path ${packagePath} conflicts with existing filesystem path ${targetPath}`);
+}
+function resolveGeneratedPath(root, relativePath) {
+    if (path.isAbsolute(relativePath)) {
+        throw new Error(`Package Addition paths must be relative: ${relativePath}`);
+    }
+    const resolvedRoot = path.resolve(root);
+    const resolvedPath = path.resolve(resolvedRoot, relativePath);
+    const insideRoot = resolvedPath === resolvedRoot ||
+        resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+    if (!insideRoot) {
+        throw new Error(`Package Addition path escapes the Generated Repository: ${relativePath}`);
+    }
+    return resolvedPath;
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertRootPackageJson(input) {
+    if (!isRecord(input)) {
+        throw new Error("Cannot update root Package Addition scripts: package.json must be an object");
+    }
+    if (!isRecord(input.scripts)) {
+        throw new Error("Cannot update root Package Addition scripts: scripts must be an object");
+    }
+    for (const scriptName of ["check", "fix"]) {
+        if (typeof input.scripts[scriptName] !== "string") {
+            throw new Error(`Cannot update root Package Addition scripts: scripts.${scriptName} must be a string`);
+        }
+    }
+}
+async function readGeneratedWorkspaceBlueprint(root) {
+    const blueprintPath = path.join(root, ".template/blueprint.json");
+    let blueprintJson;
+    try {
+        blueprintJson = await readJson(blueprintPath);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError ||
+            (isNodeError(error) && error.code === "ENOENT")) {
+            throw new Error("Package Addition requires a valid .template/blueprint.json");
+        }
+        throw error;
+    }
+    const result = validateProjectBlueprint(blueprintJson);
+    if (!result.ok) {
+        if (isRecord(blueprintJson) &&
+            blueprintJson.projectKind === "single-package") {
+            throw new Error("Package Addition only supports existing workspace Generated Repositories");
+        }
+        throw new Error("Package Addition requires a valid .template/blueprint.json");
+    }
+    const blueprint = result.value;
+    if (blueprint.projectKind !== "multi-package") {
+        throw new Error("Package Addition only supports existing workspace Generated Repositories");
+    }
+    if (blueprint.packageManager !== "pnpm") {
+        throw new Error("Package Addition only supports pnpm workspace Generated Repositories");
+    }
+    if (!blueprint.packages || blueprint.packages.length === 0) {
+        throw new Error("Package Addition requires package definitions in the stored Project Blueprint");
+    }
+    await stat(path.join(root, "turbo.json"));
+    await stat(path.join(root, "pnpm-workspace.yaml"));
+    return blueprint;
+}
+async function readGeneratedRepositoryNodeVersion(root) {
+    const packageJson = await readJson(path.join(root, "package.json"));
+    if (!isRecord(packageJson) || !isRecord(packageJson.engines)) {
+        throw new Error("Package Addition requires root package.json to declare engines.node");
+    }
+    const nodeVersion = packageJson.engines.node;
+    if (typeof nodeVersion !== "string" || nodeVersion.length === 0) {
+        throw new Error("Package Addition requires root package.json to declare engines.node");
+    }
+    return nodeVersion;
+}
+function workspaceTextWithPackageGlob(text, glob) {
+    if (text.includes(`  - ${glob}`)) {
+        return text;
+    }
+    const nextText = text.replace(/^packages:\n/m, `packages:\n  - ${glob}\n`);
+    if (nextText === text) {
+        throw new Error("Cannot update pnpm workspace membership: missing packages section");
+    }
+    return nextText;
+}
+function assertRootTsconfig(input) {
+    if (!isRecord(input)) {
+        throw new Error("Cannot update root TypeScript project references: tsconfig.json must be an object");
+    }
+    const references = input.references;
+    if (references === undefined) {
+        return;
+    }
+    if (!Array.isArray(references)) {
+        throw new Error("Cannot update root TypeScript project references: references must be an array");
+    }
+    for (const reference of references) {
+        if (!isRecord(reference) || typeof reference.path !== "string") {
+            throw new Error("Cannot update root TypeScript project references: each reference must have a string path");
+        }
+    }
+}
+function rootTsconfigWithReferences(input, referencePaths) {
+    assertRootTsconfig(input);
+    const tsconfig = input;
+    const references = tsconfig.references ?? [];
+    for (const referencePath of referencePaths) {
+        if (!references.some((reference) => reference.path === referencePath)) {
+            references.push({ path: referencePath });
+        }
+    }
+    return { ...tsconfig, references };
+}
+function packageAdditionCatalogDependencies(operations) {
+    const manifests = [];
+    for (const operation of operations) {
+        if (operation.kind !== "writeJson" ||
+            path.basename(operation.to) !== "package.json") {
+            continue;
+        }
+        if (!isRecord(operation.value)) {
+            throw new Error(`Package Addition package manifest must be an object: ${operation.to}`);
+        }
+        manifests.push(operation.value);
+    }
+    return collectGeneratedManifestCatalogReferences(manifests);
+}
+function blueprintWithPackage(blueprint, packageName, packagePath) {
+    const nextBlueprint = {
+        ...blueprint,
+        packages: [
+            ...(blueprint.packages ?? []),
+            { name: packageName, path: packagePath },
+        ],
+    };
+    const result = validateProjectBlueprint(nextBlueprint);
+    if (!result.ok) {
+        throw new Error("Package Addition would write an invalid .template/blueprint.json");
+    }
+    return result.value;
+}
+function workspacePackageGlobsFromBlueprint(blueprint) {
+    const globs = [];
+    for (const packageDefinition of blueprint.packages ?? []) {
+        const [workspaceDir] = packageDefinition.path.split("/");
+        if (!workspaceDir) {
+            throw new Error(`Cannot update root Package Addition scripts: invalid package path ${packageDefinition.path}`);
+        }
+        const glob = `${workspaceDir}/*`;
+        if (!globs.includes(glob)) {
+            globs.push(glob);
+        }
+    }
+    return globs;
+}
+function turboPackageTaskCommand(task, workspacePackageGlobs) {
+    const filters = workspacePackageGlobs.map((glob) => `--filter './${glob}'`);
+    return [`turbo run ${task}`, ...filters].join(" ");
+}
+function rootScriptWithTurboPackageTask(script, task, workspacePackageGlobs) {
+    const commands = script.split(" && ");
+    const turboCommandIndex = commands.findIndex((command) => command.startsWith(`turbo run ${task}`));
+    if (turboCommandIndex === -1) {
+        throw new Error(`Cannot update root Package Addition scripts: scripts.${task} must run Turbo package tasks`);
+    }
+    commands[turboCommandIndex] = turboPackageTaskCommand(task, workspacePackageGlobs);
+    return commands.join(" && ");
+}
+function rootPackageJsonWithPackageTaskFilters(input, blueprint) {
+    assertRootPackageJson(input);
+    const workspacePackageGlobs = workspacePackageGlobsFromBlueprint(blueprint);
+    return {
+        ...input,
+        scripts: {
+            ...input.scripts,
+            check: rootScriptWithTurboPackageTask(input.scripts.check, "check", workspacePackageGlobs),
+            fix: rootScriptWithTurboPackageTask(input.scripts.fix, "fix", workspacePackageGlobs),
+        },
+    };
+}
+async function planRootUpdates(root, blueprint, packageName, packagePath, workspacePackageGlob, rootTsconfigReferences, catalogDependencies) {
+    const nextBlueprint = blueprintWithPackage(blueprint, packageName, packagePath);
+    const workspaceText = pnpmWorkspaceYamlWithCatalogDependencies(workspaceTextWithPackageGlob(await readFile(path.join(root, "pnpm-workspace.yaml"), "utf8"), workspacePackageGlob), catalogDependencies);
+    const rootTsconfig = rootTsconfigWithReferences(await readJson(path.join(root, "tsconfig.json")), rootTsconfigReferences);
+    const rootPackageJson = rootPackageJsonWithPackageTaskFilters(await readJson(path.join(root, "package.json")), nextBlueprint);
+    return {
+        blueprint: nextBlueprint,
+        rootPackageJson,
+        rootTsconfig,
+        workspaceText,
+    };
+}
+export async function addPackage(options) {
+    assertSafePackageLeaf(options.name);
+    const root = path.resolve(options.cwd);
+    const blueprint = await readGeneratedWorkspaceBlueprint(root);
+    const nodeVersion = await readGeneratedRepositoryNodeVersion(root);
+    const projectName = projectNameFromBlueprint(blueprint);
+    const packageName = `@${projectName}/${options.name}`;
+    const packagePath = options.path
+        ? validateExplicitPackagePath(options.path)
+        : defaultPackagePathForPreset(options.preset, options.name);
+    const projection = findBuiltInPresetProjection(options.preset);
+    const packageAddition = projection?.capabilities?.packageAddition;
+    if (!projection) {
+        throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
+    }
+    if (!packageAddition) {
+        throw new Error(`Package Addition is not supported by preset: ${options.preset}`);
+    }
+    const additionPlan = await packageAddition.planPackageAddition({
+        root,
+        blueprint,
+        packageLeafName: options.name,
+        packageName,
+        packagePath,
+        nodeVersion,
+    });
+    assertNoPackageConflict(blueprint, packageName, additionPlan.packagePath);
+    await assertMissingPackagePath(additionPlan.packagePath, path.join(root, additionPlan.packagePath));
+    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.workspacePackageGlob, additionPlan.rootTsconfigReferences, packageAdditionCatalogDependencies(additionPlan.operations));
+    await mkdir(path.join(root, additionPlan.packagePath), { recursive: true });
+    await renderProject({
+        sourceRoot: additionPlan.sourceRoot,
+        sourceRoots: additionPlan.sourceRoots,
+        targetRoot: root,
+        operations: [...additionPlan.operations],
+    });
+    for (const textFile of additionPlan.textFiles ?? []) {
+        await writeFile(resolveGeneratedPath(root, textFile.path), textFile.text, "utf8");
+    }
+    await writeFile(path.join(root, "pnpm-workspace.yaml"), rootUpdatePlan.workspaceText, "utf8");
+    await writeJson(path.join(root, "package.json"), rootUpdatePlan.rootPackageJson);
+    await writeJson(path.join(root, "tsconfig.json"), rootUpdatePlan.rootTsconfig);
+    await writeJson(path.join(root, ".template/blueprint.json"), rootUpdatePlan.blueprint);
+}

package/dist/src/preset-projection.d.ts

@@ -0,0 +1,66 @@
+import type { BuiltInPreset, ProjectBlueprint } from "./declarations.js";
+import type { GenerationContext } from "./generation-context.js";
+import { type CheckPlan, type FixPlan } from "./module-graph.js";
+import { type NextStepInstruction } from "./next-step-instructions.js";
+import type { DependencyMaintenancePolicy } from "./project-github.js";
+import type { RenderOperation } from "./renderer.js";
+export type PresetPackageAdditionOptions = {
+    readonly root: string;
+    readonly blueprint: ProjectBlueprint;
+    readonly packageLeafName: string;
+    readonly packageName: string;
+    readonly packagePath: string;
+    readonly nodeVersion: string;
+};
+export type PresetPackageAdditionPlan = {
+    readonly packagePath: string;
+    readonly workspacePackageGlob: string;
+    readonly rootTsconfigReferences: readonly string[];
+    readonly sourceRoot: string;
+    readonly sourceRoots?: Record<string, string>;
+    readonly operations: readonly RenderOperation[];
+    readonly textFiles?: readonly {
+        readonly path: string;
+        readonly text: string;
+    }[];
+};
+export type PresetPackageAdditionCapability = {
+    planPackageAddition(options: PresetPackageAdditionOptions): PresetPackageAdditionPlan | Promise<PresetPackageAdditionPlan>;
+};
+export type PresetProjectionPlan = {
+    readonly sourceRoot: string;
+    readonly sourceRoots?: Record<string, string>;
+    readonly operations: readonly RenderOperation[];
+    readonly checkPlan: CheckPlan;
+    readonly fixPlan: FixPlan;
+    readonly dependencyMaintenancePolicy: DependencyMaintenancePolicy;
+    readonly packageScripts: Record<string, string>;
+    readonly capabilities: {
+        readonly rootCheck: true;
+        readonly fixCommand: true;
+        readonly githubActions: true;
+        readonly dependabot: true;
+        readonly devcontainer: true;
+    };
+};
+export type PresetBlueprintOptions = {
+    readonly targetDir: string;
+    readonly scope?: string;
+};
+export type RenderPresetProjectionOptions = {
+    readonly targetDir: string;
+    readonly plan: PresetProjectionPlan;
+};
+export type PresetProjection = {
+    readonly metadata: BuiltInPreset;
+    readonly capabilities?: {
+        readonly packageAddition?: PresetPackageAdditionCapability;
+    };
+    blueprint(options: PresetBlueprintOptions): ProjectBlueprint;
+    project(context: GenerationContext): PresetProjectionPlan;
+    render(options: RenderPresetProjectionOptions): Promise<void>;
+};
+export declare function planNextStepInstructionsForProjection(options: {
+    readonly targetDir: string;
+    readonly plan: PresetProjectionPlan;
+}): readonly NextStepInstruction[];

package/dist/src/preset-projection.js

@@ -0,0 +1,7 @@
+import { planNextStepInstructions, } from "./next-step-instructions.js";
+export function planNextStepInstructionsForProjection(options) {
+    return planNextStepInstructions({
+        targetDir: options.targetDir,
+        projectionPlan: options.plan,
+    }).steps;
+}

package/dist/{project-github.d.ts → src/project-github.d.ts}

@@ -1,4 +1,3 @@
-import type { PresetName } from "./declarations.js";
 import { type CheckPlan } from "./module-graph.js";
 export type CiCapability = {
     readonly workflowName: "Check";
@@ -13,9 +12,11 @@ export type PnpmTaskLayer = {
     readonly installCommand: "pnpm install";
     readonly checkCommand: "pnpm run check";
 };
-export type DependencyEcosystem = "npm" | "cargo" | "github-actions";
+export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "rust-toolchain";
+export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
     readonly ecosystems: DependencyEcosystem[];
+    readonly directories?: Partial<Record<DependencyEcosystem, DependabotDirectory>>;
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
@@ -23,14 +24,7 @@ type ProjectCheckWorkflowOptions = {
     readonly capability?: CiCapability;
     readonly environmentPreparation?: Partial<CiEnvironmentPreparation>;
     readonly taskLayer?: PnpmTaskLayer;
-    readonly rustToolchain?: boolean;
 };
-export declare function projectPresetGithubCheckWorkflow(preset: PresetName): string;
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
-export declare function projectPresetDependencyMaintenancePolicy(preset: PresetName): DependencyMaintenancePolicy;
-export declare function projectPresetDependabotConfig(preset: PresetName): string;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;
-export declare function projectTsLibGithubCheckWorkflow(): string;
-export declare function projectRustBinGithubCheckWorkflow(): string;
 export {};
-//# sourceMappingURL=project-github.d.ts.map

package/dist/{project-github.js → src/project-github.js}

@@ -1,4 +1,3 @@
-import { planNodeChecks, planPresetChecks, planRustBinChecks, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -8,21 +7,11 @@ const pnpmTaskLayer = {
     installCommand: "pnpm install",
     checkCommand: "pnpm run check",
 };
-export function projectPresetGithubCheckWorkflow(preset) {
-    const checkPlan = planPresetChecks(preset);
-    if (!checkPlan) {
-        throw new Error(`Unsupported preset for GitHub check workflow projection: ${preset}`);
-    }
-    return projectCheckWorkflow({
-        checkPlan,
-        rustToolchain: preset === "rust-bin",
-    });
-}
 export function projectCheckWorkflow(options) {
     const capability = options.capability ?? defaultCiCapability;
     const environmentPreparation = {
         nodeFromPackageMetadata: true,
-        rustToolchain: options.rustToolchain ?? false,
+        rustToolchain: false,
         ...options.environmentPreparation,
     };
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
@@ -52,45 +41,41 @@ export function projectCheckWorkflow(options) {
     lines.push(`      - run: ${taskLayer.checkCommand}`, "");
     return lines.join("\n");
 }
-export function projectPresetDependencyMaintenancePolicy(preset) {
-    switch (preset) {
-        case "ts-lib":
-        case "hono-api":
-        case "vue-app":
-        case "vue-hono-app":
-            return { ecosystems: ["npm", "github-actions"], interval: "weekly" };
-        case "rust-bin":
-            return { ecosystems: ["npm", "cargo", "github-actions"], interval: "weekly" };
-        case "ts-app":
-        case "node-cli":
-            throw new Error(`Unsupported preset for Dependency Maintenance Policy projection: ${preset}`);
-    }
-}
-export function projectPresetDependabotConfig(preset) {
-    return projectDependabotConfig(projectPresetDependencyMaintenancePolicy(preset));
-}
 export function projectDependabotConfig(policy) {
     return [
         "version: 2",
+        "",
         "updates:",
-        ...policy.ecosystems.flatMap((ecosystem) => [
-            `  - package-ecosystem: ${ecosystem}`,
-            "    directory: /",
-            "    schedule:",
-            `      interval: ${policy.interval}`,
-        ]),
+        ...policy.ecosystems.flatMap((ecosystem) => renderDependabotUpdate(ecosystem, policy.directories?.[ecosystem] ??
+            defaultDependabotDirectory(ecosystem), policy.interval)),
         "",
     ].join("\n");
 }
+function renderDependabotUpdate(ecosystem, directory, interval) {
+    const lines = [
+        `  - package-ecosystem: ${ecosystem}`,
+        `    directory: ${renderDependabotDirectory(ecosystem, directory)}`,
+        "    schedule:",
+        `      interval: ${interval}`,
+    ];
+    if (ecosystem === "npm") {
+        lines.push("    ignore:", '      - dependency-name: "@types/node"', "        update-types:", "          - version-update:semver-major");
+    }
+    if (ecosystem === "docker") {
+        lines.push("    ignore:", "      - dependency-name: mcr.microsoft.com/devcontainers/typescript-node", "        update-types:", "          - version-update:semver-major");
+    }
+    return lines;
+}
+function renderDependabotDirectory(ecosystem, directory) {
+    return ecosystem === "cargo" ? JSON.stringify(directory) : directory;
+}
+function defaultDependabotDirectory(ecosystem) {
+    return ecosystem === "docker" ? "/.devcontainer" : "/";
+}
 function renderCiEnvironmentNeedCommand(need) {
-    if (need.kind === "playwright-browser-assets" && need.owner.path === "apps/web") {
+    if (need.kind === "playwright-browser-assets" &&
+        need.owner.path === "apps/web") {
         return `pnpm --filter ./apps/web exec playwright install --with-deps ${need.browser}`;
     }
     return `pnpm exec playwright install --with-deps ${need.browser}`;
 }
-export function projectTsLibGithubCheckWorkflow() {
-    return projectCheckWorkflow({ checkPlan: planNodeChecks("ts-lib") });
-}
-export function projectRustBinGithubCheckWorkflow() {
-    return projectCheckWorkflow({ checkPlan: planRustBinChecks(), rustToolchain: true });
-}