@ykdz/template 0.0.23 → 0.0.24

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

@@ -1,6 +1,29 @@
 import { constants } from "node:fs";
-import { chmod, copyFile, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat, writeFile, } from "node:fs/promises";
+import { chmod, cp, copyFile, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat, writeFile, } from "node:fs/promises";
 import path from "node:path";
+/**
+ * An opaque, owned Template Source reference.  A renderer operation carries
+ * this directly instead of selecting a root from a string-keyed side map.
+ */
+const templateSourceHandleBrand = Symbol("template-source");
+const templateSourceRoots = new WeakMap();
+export function createTemplateSourceHandle(root) {
+    const handle = Object.freeze({
+        [templateSourceHandleBrand]: true,
+    });
+    templateSourceRoots.set(handle, path.resolve(root));
+    return handle;
+}
+/** Resolves a handle-owned source path while enforcing containment. */
+export function resolveTemplateSource(source, relativePath) {
+    const root = typeof source === "object" && source !== null
+        ? templateSourceRoots.get(source)
+        : undefined;
+    if (root === undefined) {
+        throw new Error("Renderer received an unknown Template Source handle");
+    }
+    return resolveContainedPath(root, relativePath);
+}
 function expandTemplatePath(templatePath, variables) {
     return templatePath.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_, name) => {
         const value = variables[name];
@@ -31,17 +54,11 @@ function expandOperationPath(relativePath, options) {
 }
 async function renderCopyFile(operation, options) {
     const variables = options.variables ?? {};
-    const sourceRoot = operation.sourceRoot === undefined
-        ? options.sourceRoot
-        : options.sourceRoots?.[operation.sourceRoot];
-    if (sourceRoot === undefined) {
-        throw new Error(`Unknown renderer source root: ${operation.sourceRoot}`);
-    }
-    const from = resolveContainedPath(sourceRoot, expandTemplatePath(operation.from, variables));
+    const from = resolveTemplateSource(operation.source, expandTemplatePath(operation.from, variables));
     const to = resolveContainedPath(options.targetRoot, expandTemplatePath(operation.to, variables));
     const sourceMode = (await stat(from)).mode;
     await mkdir(path.dirname(to), { recursive: true });
-    await copyGeneratedFile(from, to);
+    await copyGeneratedFile(from, to, operation.overwrite ?? false);
     await chmod(to, sourceMode & 0o777);
 }
 function isRecord(value) {
@@ -147,7 +164,7 @@ async function writeJsonFile(targetRoot, toPath, value, multilineArrays, overwri
     await writeGeneratedFile(to, serializeJson(value, multilineArrays, rootKeyOrderForPath(toPath)), overwrite);
 }
 async function renderWriteJson(operation, options) {
-    await writeJsonFile(options.targetRoot, expandOperationPath(operation.to, options), operation.value, operation.multilineArrays);
+    await writeJsonFile(options.targetRoot, expandOperationPath(operation.to, options), operation.value, operation.multilineArrays, operation.overwrite);
 }
 async function renderMergeJson(operation, options) {
     const toPath = expandOperationPath(operation.to, options);
@@ -161,7 +178,7 @@ async function renderMergeJson(operation, options) {
             throw error;
         }
     }
-    await writeJsonFile(options.targetRoot, toPath, mergeJsonValue(existing, operation.value), undefined, true);
+    await writeJsonFile(options.targetRoot, toPath, mergeJsonValue(existing, operation.value), operation.multilineArrays, true);
 }
 const foundationTextFiles = new Set([
     ".dockerignore",
@@ -209,6 +226,9 @@ function assertFoundationTextPath(relativePath) {
     if (normalizedPath === ".devcontainer/Dockerfile") {
         return;
     }
+    if (normalizedPath === ".devcontainer/devcontainer.json") {
+        return;
+    }
     throw new Error(`Text output is limited to foundation files: ${relativePath}`);
 }
 function assertTextTemplatePath(relativePath) {
@@ -233,18 +253,12 @@ async function renderWriteTextFromFragments(operation, options) {
     assertFoundationTextPath(toPath);
     const to = resolveContainedPath(options.targetRoot, toPath);
     const texts = await Promise.all(operation.fragments.map(async (fragment) => {
-        const sourceRoot = fragment.sourceRoot === undefined
-            ? options.sourceRoot
-            : options.sourceRoots?.[fragment.sourceRoot];
-        if (sourceRoot === undefined) {
-            throw new Error(`Unknown renderer source root: ${fragment.sourceRoot}`);
-        }
         const fromPath = expandTemplatePath(fragment.from, options.variables ?? {});
-        const from = resolveContainedPath(sourceRoot, fromPath);
+        const from = resolveTemplateSource(fragment.source, fromPath);
         return readFile(from, "utf8");
     }));
     await mkdir(path.dirname(to), { recursive: true });
-    await writeGeneratedFile(to, texts.map((text) => text.trimEnd()).join("\n\n") + "\n");
+    await writeGeneratedFile(to, texts.map((text) => text.trimEnd()).join("\n\n") + "\n", operation.overwrite ?? false);
 }
 function replaceTextTemplateVariables(sourceText, replacements) {
     const used = new Set();
@@ -264,19 +278,13 @@ function replaceTextTemplateVariables(sourceText, replacements) {
     return rendered;
 }
 async function renderWriteTextTemplate(operation, options) {
-    const sourceRoot = operation.sourceRoot === undefined
-        ? options.sourceRoot
-        : options.sourceRoots?.[operation.sourceRoot];
-    if (sourceRoot === undefined) {
-        throw new Error(`Unknown renderer source root: ${operation.sourceRoot}`);
-    }
     const toPath = expandOperationPath(operation.to, options);
     assertTextTemplatePath(toPath);
-    const from = resolveContainedPath(sourceRoot, expandTemplatePath(operation.from, options.variables ?? {}));
+    const from = resolveTemplateSource(operation.source, expandTemplatePath(operation.from, options.variables ?? {}));
     const to = resolveContainedPath(options.targetRoot, toPath);
     const sourceText = await readFile(from, "utf8");
     await mkdir(path.dirname(to), { recursive: true });
-    await writeGeneratedFile(to, replaceTextTemplateVariables(sourceText, operation.replacements));
+    await writeGeneratedFile(to, replaceTextTemplateVariables(sourceText, operation.replacements), operation.overwrite);
 }
 async function renderSetExecutable(operation, options) {
     const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
@@ -296,7 +304,7 @@ function parseAnchorComment(commentText) {
     return multiline?.[1];
 }
 async function findTypeScriptAnchorRanges(sourceText) {
-    const ts = await import("@typescript/typescript6");
+    const ts = await import("typescript");
     const sourceFile = ts.createSourceFile("template-anchor.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const anchors = [];
     const seenRanges = new Set();
@@ -377,9 +385,9 @@ async function targetDirectoryStatus(targetRoot) {
     }
     return "empty";
 }
-async function copyGeneratedFile(from, to) {
+async function copyGeneratedFile(from, to, overwrite = false) {
     try {
-        await copyFile(from, to, constants.COPYFILE_EXCL);
+        await copyFile(from, to, overwrite ? 0 : constants.COPYFILE_EXCL);
     }
     catch (error) {
         if (isNodeError(error) && error.code === "EEXIST") {
@@ -443,6 +451,83 @@ export async function renderProject(options) {
         throw new Error(`Unsupported renderer operation: ${operation.kind}`);
     }
 }
+/**
+ * Applies a follow-up plan in a sibling staging directory.  In particular,
+ * metadata updates cannot become visible when a later source operation fails.
+ */
+export async function renderProjectAtomically(options) {
+    const targetRoot = path.resolve(options.targetRoot);
+    await stat(targetRoot);
+    const parent = path.dirname(targetRoot);
+    const stagingRoot = await mkdtemp(path.join(parent, `.${path.basename(targetRoot)}.template-update-`));
+    const backupRoot = await mkdtemp(path.join(parent, `.${path.basename(targetRoot)}.template-backup-`));
+    const changedEntries = changedRootEntries(options.operations);
+    let committed = false;
+    try {
+        await cp(targetRoot, stagingRoot, { recursive: true });
+        await renderProject({ ...options, targetRoot: stagingRoot });
+        // Commit only the entries changed by the staged plan.  In particular, do
+        // not rename the target directory: callers commonly run `template add`
+        // from that directory, and renaming it leaves their shell on a deleted
+        // inode.  Each entry has a rollback copy before it is made visible.
+        for (const entry of changedEntries) {
+            const current = path.join(targetRoot, entry);
+            try {
+                await cp(current, path.join(backupRoot, entry), { recursive: true });
+            }
+            catch (error) {
+                if (!isNodeError(error) || error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        try {
+            for (const entry of changedEntries) {
+                await cp(path.join(stagingRoot, entry), path.join(targetRoot, entry), {
+                    recursive: true,
+                    force: true,
+                });
+            }
+            committed = true;
+        }
+        catch (error) {
+            await rollbackStagedEntries({ targetRoot, backupRoot, changedEntries });
+            throw error;
+        }
+    }
+    finally {
+        if (!committed)
+            await rm(stagingRoot, { recursive: true, force: true });
+        await rm(backupRoot, { recursive: true, force: true });
+        if (committed)
+            await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+function changedRootEntries(operations) {
+    const entries = new Set();
+    for (const operation of operations) {
+        const outputPath = operation.kind === "setExecutable" || operation.kind === "replaceAnchors"
+            ? operation.path
+            : operation.to;
+        const entry = outputPath.split(/[\\/]/)[0];
+        if (entry !== undefined && entry.length > 0)
+            entries.add(entry);
+    }
+    return [...entries];
+}
+async function rollbackStagedEntries(options) {
+    for (const entry of options.changedEntries) {
+        const target = path.join(options.targetRoot, entry);
+        const backup = path.join(options.backupRoot, entry);
+        await rm(target, { recursive: true, force: true });
+        try {
+            await cp(backup, target, { recursive: true });
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
 async function commitStagedProject(stagingRoot, targetRoot) {
     const targetStatus = await targetDirectoryStatus(targetRoot);
     if (targetStatus === "empty") {

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

@@ -1,38 +1,44 @@
-import type { RenderOperation } from "./renderer.js";
-export type TemplateBoundaryDebt = {
-    readonly preset: string;
-    readonly generatedPath: string;
-    readonly owningFunction: string;
-    readonly reason: string;
-};
+import { type RenderOperation } from "./renderer.ts";
 export type TemplateBoundaryViolation = {
     readonly preset: string;
     readonly generatedPath: string;
     readonly owningFunction: string;
     readonly operationKind: RenderOperation["kind"];
     readonly sourceFilePath: string;
-    readonly allowlistReason?: string;
+    /** Real registry plans retain their Definition and contribution provenance. */
+    readonly definitionName?: string;
+    readonly planningContribution?: string;
+    readonly ownershipRule?: string;
 };
 export type TemplateBoundaryCheckProjection = {
     readonly name: string;
     readonly sourceFilePath: string;
+    readonly definitionName?: string;
+    readonly planningContribution?: string;
     readonly plan: {
-        readonly sourceRoot: string;
-        readonly sourceRoots?: Record<string, string> | undefined;
         readonly operations: readonly RenderOperation[];
     };
 };
+/** A Template Source root directly checked independently of any render plan. */
+export type TemplateSourceContext = {
+    readonly name: string;
+    readonly root: string;
+    /** Every readable source file discovered by a direct Template Source check. */
+    readonly checkedFiles?: readonly string[];
+};
 export type TemplateBoundaryCheckResult = {
     readonly ok: boolean;
     readonly violations: readonly TemplateBoundaryViolation[];
-    readonly allowlistedDebt: readonly TemplateBoundaryViolation[];
-    readonly unusedAllowlistEntries: readonly TemplateBoundaryDebt[];
 };
 export type CheckTemplateSourceBoundaryOptions = {
     readonly projections: readonly TemplateBoundaryCheckProjection[];
+    readonly templateSourceContexts?: readonly TemplateSourceContext[];
     readonly manifestReferencedSourceFiles?: readonly string[];
-    readonly allowlist?: readonly TemplateBoundaryDebt[];
 };
-export declare const templateBoundaryDebtAllowlist: readonly TemplateBoundaryDebt[];
+/**
+ * Reads each registered Template Source context before any plan is inspected.
+ * The resulting file sets are an independent proof consumed by the boundary check.
+ */
+export declare function checkTemplateSourceContexts(contexts: readonly Omit<TemplateSourceContext, "checkedFiles">[]): Promise<readonly TemplateSourceContext[]>;
 export declare function isProtectedGeneratedPath(generatedPath: string): boolean;
-export declare function checkTemplateSourceBoundary({ projections, manifestReferencedSourceFiles, allowlist, }: CheckTemplateSourceBoundaryOptions): Promise<TemplateBoundaryCheckResult>;
+export declare function checkTemplateSourceBoundary({ projections, templateSourceContexts, manifestReferencedSourceFiles, }: CheckTemplateSourceBoundaryOptions): Promise<TemplateBoundaryCheckResult>;

package/node_modules/@ykdz/template-core/dist/template-boundary-check.js

@@ -1,12 +1,46 @@
-import { readFile } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import ts from "@typescript/typescript6";
+import ts from "typescript";
+import { resolveTemplateSource } from "./renderer.js";
 const inlineOperationKinds = new Set([
     "writeText",
     "writeJson",
     "mergeJson",
 ]);
-export const templateBoundaryDebtAllowlist = [];
+async function listTemplateSourceFiles(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listTemplateSourceFiles(entryPath)));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        await readFile(entryPath);
+        files.push(path.resolve(entryPath));
+    }
+    return files;
+}
+/**
+ * Reads each registered Template Source context before any plan is inspected.
+ * The resulting file sets are an independent proof consumed by the boundary check.
+ */
+export async function checkTemplateSourceContexts(contexts) {
+    return await Promise.all(contexts.map(async (context) => {
+        const root = path.resolve(context.root);
+        const rootStats = await stat(root);
+        if (!rootStats.isDirectory()) {
+            throw new Error(`Template Source context ${context.name} root is not a directory: ${root}`);
+        }
+        return {
+            ...context,
+            root,
+            checkedFiles: await listTemplateSourceFiles(root),
+        };
+    }));
+}
 function operationTarget(operation) {
     if ("to" in operation) {
         return operation.to;
@@ -464,33 +498,46 @@ function isAllowedStructuralMachineDeclaration(sourceFile, operation) {
             return value !== undefined && isDevelopmentContainerPlanValue(value);
         }));
 }
-function allowlistKey(preset, generatedPath, owningFunction) {
-    return `${preset}\0${owningFunction}\0${generatedPath}`;
-}
-function resolveOperationSourceRoot(projection, sourceRootName) {
-    if (sourceRootName === undefined) {
-        return projection.plan.sourceRoot;
-    }
-    return projection.plan.sourceRoots?.[sourceRootName];
-}
 function sourceBackedOperationSourceFiles(projection, operation) {
     if (operation.kind === "writeTextFromFragments") {
         return operation.fragments.map((fragment) => {
-            const root = resolveOperationSourceRoot(projection, fragment.sourceRoot);
-            return root === undefined
-                ? `missing-source-root:${fragment.sourceRoot}`
-                : path.resolve(root, fragment.from);
+            try {
+                return resolveTemplateSource(fragment.source, fragment.from);
+            }
+            catch (error) {
+                return `invalid-source:${error instanceof Error ? error.message : String(error)}`;
+            }
         });
     }
-    const root = resolveOperationSourceRoot(projection, operation.sourceRoot);
-    return [
-        root === undefined
-            ? `missing-source-root:${operation.sourceRoot}`
-            : path.resolve(root, operation.from),
-    ];
+    try {
+        return [resolveTemplateSource(operation.source, operation.from)];
+    }
+    catch (error) {
+        return [
+            `invalid-source:${error instanceof Error ? error.message : String(error)}`,
+        ];
+    }
 }
-function operationUsesManifestReferencedSource(projection, operation, manifestReferencedSourceFiles) {
-    return sourceBackedOperationSourceFiles(projection, operation).every((sourceFile) => manifestReferencedSourceFiles.has(sourceFile));
+async function operationUsesCheckedTemplateSource(projection, operation, templateSourceContexts, manifestReferencedSourceFiles) {
+    const sourceFiles = sourceBackedOperationSourceFiles(projection, operation);
+    const results = await Promise.all(sourceFiles.map(async (sourceFile) => {
+        const context = templateSourceContexts.find((candidate) => {
+            const root = path.resolve(candidate.root);
+            return (sourceFile.startsWith(`${root}${path.sep}`) || sourceFile === root);
+        });
+        if (context === undefined) {
+            return manifestReferencedSourceFiles.has(sourceFile);
+        }
+        const relativePath = path.relative(path.resolve(context.root), sourceFile);
+        if (relativePath.length === 0 ||
+            relativePath === ".." ||
+            relativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativePath)) {
+            return false;
+        }
+        return context.checkedFiles?.includes(sourceFile) ?? false;
+    }));
+    return results.every(Boolean);
 }
 function pushSourceBackedOperationViolations(options) {
     const generatedPath = operationTarget(options.operation);
@@ -504,26 +551,31 @@ function pushSourceBackedOperationViolations(options) {
             generatedPath,
             owningFunction,
             operationKind: options.operation.kind,
-            sourceFilePath: options.projection.sourceFilePath,
+            sourceFilePath: options.operation.provenance?.plannerSourceFile ??
+                options.projection.sourceFilePath,
+            ...(options.operation.provenance === undefined &&
+                options.projection.definitionName === undefined
+                ? {}
+                : {
+                    definitionName: options.operation.provenance?.definitionName ??
+                        options.projection.definitionName,
+                    planningContribution: options.operation.provenance?.planningContribution ??
+                        options.projection.planningContribution,
+                    ownershipRule: options.operation.provenance?.ownershipRule ??
+                        "source-backed protected output must use declared, contained Template Source",
+                }),
         });
     }
 }
-export async function checkTemplateSourceBoundary({ projections, manifestReferencedSourceFiles = [], allowlist = [], }) {
+export async function checkTemplateSourceBoundary({ projections, templateSourceContexts = [], manifestReferencedSourceFiles = [], }) {
     const manifestReferencedSourceFileSet = new Set(manifestReferencedSourceFiles.map((sourceFile) => path.resolve(sourceFile)));
-    const allowed = new Map(allowlist.map((entry) => [
-        allowlistKey(entry.preset, entry.generatedPath, entry.owningFunction),
-        entry.reason,
-    ]));
-    const checkedPresets = new Set(projections.map((projection) => projection.name));
-    const usedAllowlistKeys = new Set();
     const violations = [];
-    const allowlistedDebt = [];
     for (const projection of projections) {
         const sourceText = await readFile(projection.sourceFilePath, "utf8");
         const sourceFile = ts.createSourceFile(projection.sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
         for (const operation of projection.plan.operations) {
             if (isProtectedSourceBackedOperation(operation)) {
-                if (!operationUsesManifestReferencedSource(projection, operation, manifestReferencedSourceFileSet)) {
+                if (!(await operationUsesCheckedTemplateSource(projection, operation, templateSourceContexts, manifestReferencedSourceFileSet))) {
                     pushSourceBackedOperationViolations({
                         projection,
                         sourceFile,
@@ -549,28 +601,26 @@ export async function checkTemplateSourceBoundary({ projections, manifestReferen
                     generatedPath: operation.to,
                     owningFunction,
                     operationKind: operation.kind,
-                    sourceFilePath: projection.sourceFilePath,
+                    sourceFilePath: operation.provenance?.plannerSourceFile ??
+                        projection.sourceFilePath,
+                    ...(operation.provenance === undefined &&
+                        projection.definitionName === undefined
+                        ? {}
+                        : {
+                            definitionName: operation.provenance?.definitionName ??
+                                projection.definitionName,
+                            planningContribution: operation.provenance?.planningContribution ??
+                                projection.planningContribution,
+                            ownershipRule: operation.provenance?.ownershipRule ??
+                                "protected generated output must be Template Source-backed",
+                        }),
                 };
-                const allowlistReason = allowed.get(allowlistKey(projection.name, operation.to, owningFunction));
-                if (allowlistReason) {
-                    usedAllowlistKeys.add(allowlistKey(projection.name, operation.to, owningFunction));
-                    allowlistedDebt.push({ ...diagnostic, allowlistReason });
-                    continue;
-                }
                 violations.push(diagnostic);
             }
         }
     }
-    const unusedAllowlistEntries = allowlist.filter((entry) => {
-        if (!checkedPresets.has(entry.preset)) {
-            return false;
-        }
-        return !usedAllowlistKeys.has(allowlistKey(entry.preset, entry.generatedPath, entry.owningFunction));
-    });
     return {
-        ok: violations.length === 0 && unusedAllowlistEntries.length === 0,
+        ok: violations.length === 0,
         violations,
-        allowlistedDebt,
-        unusedAllowlistEntries,
     };
 }

package/node_modules/@ykdz/template-core/dist/toolchain-baseline-update.d.ts

@@ -0,0 +1,45 @@
+export type ToolchainBaseline = {
+    readonly nodeLtsMajor: string;
+    readonly packageManagerPin: `pnpm@${string}`;
+};
+export type ToolchainPullRequestCandidate = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "open";
+    readonly pullRequestNumber: number;
+};
+export type ToolchainRemoteBranch = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "present";
+    readonly sha: string;
+};
+export type ToolchainUpdateCandidate = {
+    readonly pullRequest: ToolchainPullRequestCandidate;
+    readonly remoteBranch: ToolchainRemoteBranch;
+};
+export type ToolchainBaselineUpdatePlan = {
+    readonly kind: "no-drift";
+} | {
+    readonly kind: "cleanup-stale";
+    readonly pullRequestNumber?: number;
+    readonly deleteBranch: true;
+} | {
+    readonly kind: "update";
+    readonly mode: "create";
+    readonly desired: ToolchainBaseline;
+} | {
+    readonly kind: "update";
+    readonly mode: "replace";
+    readonly pullRequestNumber: number;
+    readonly desired: ToolchainBaseline;
+};
+type PlanToolchainBaselineUpdateOptions = {
+    readonly current: ToolchainBaseline & {
+        readonly materialConsistent?: boolean;
+    };
+    readonly desired: ToolchainBaseline;
+    readonly candidate: ToolchainUpdateCandidate;
+};
+export declare function planToolchainBaselineUpdate(options: PlanToolchainBaselineUpdateOptions): ToolchainBaselineUpdatePlan;
+export {};

package/node_modules/@ykdz/template-core/dist/toolchain-baseline-update.js

@@ -0,0 +1,27 @@
+export function planToolchainBaselineUpdate(options) {
+    const hasDrift = options.current.materialConsistent === false ||
+        options.current.nodeLtsMajor !== options.desired.nodeLtsMajor ||
+        options.current.packageManagerPin !== options.desired.packageManagerPin;
+    if (!hasDrift) {
+        return options.candidate.pullRequest.kind === "absent" &&
+            options.candidate.remoteBranch.kind === "absent"
+            ? { kind: "no-drift" }
+            : {
+                kind: "cleanup-stale",
+                ...(options.candidate.pullRequest.kind === "open"
+                    ? {
+                        pullRequestNumber: options.candidate.pullRequest.pullRequestNumber,
+                    }
+                    : {}),
+                deleteBranch: true,
+            };
+    }
+    return options.candidate.pullRequest.kind === "absent"
+        ? { kind: "update", mode: "create", desired: options.desired }
+        : {
+            kind: "update",
+            mode: "replace",
+            pullRequestNumber: options.candidate.pullRequest.pullRequestNumber,
+            desired: options.desired,
+        };
+}

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

@@ -18,6 +18,7 @@ export type ResolveToolchainVersionsOptions = {
     readonly fetchJson?: ((url: string) => Promise<unknown>) | undefined;
     readonly nodeReleaseIndexUrl?: string | undefined;
     readonly pnpmRegistryUrl?: string | undefined;
+    readonly now?: Date | string | undefined;
 };
 export declare const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
 export declare const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";