@ykdz/template 0.0.23 → 0.0.25

package/node_modules/@ykdz/template-core/dist/project-github.js

@@ -1,4 +1,4 @@
-import { deploymentCheckEnvironmentNeeds, deploymentCheckTaskName, renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -15,9 +15,11 @@ export function projectCheckWorkflow(options) {
         rustToolchain: false,
         ...options.environmentPreparation,
     };
+    const requiresRustToolchain = environmentPreparation.rustToolchain ||
+        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
-    const deploymentChecks = options.checkPlan.deploymentChecks ?? [];
-    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
+    const hasDeploymentTask = options.hasDeploymentTask === true;
+    const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
     const lines = [
         `name: ${capability.workflowName}`,
         "",
@@ -30,28 +32,83 @@ export function projectCheckWorkflow(options) {
         "jobs:",
         `  ${capability.jobName}:`,
         `    runs-on: ${capability.runner}`,
+        ...(hasDeploymentTask
+            ? ["    strategy:", "      matrix:", "        check: [root, deployment]"]
+            : []),
         "    steps:",
         "      - uses: actions/checkout@v7",
     ];
     if (environmentPreparation.nodeFromPackageMetadata) {
         lines.push("      - uses: actions/setup-node@v6", "        with:", "          node-version-file: package.json", "      - run: corepack enable");
     }
-    if (needsDocker) {
-        lines.push("      - uses: docker/setup-buildx-action@v3");
-    }
-    if (environmentPreparation.rustToolchain) {
-        lines.push("      - uses: dtolnay/rust-toolchain@stable", "        with:", "          components: rustfmt, clippy", "      - uses: Swatinem/rust-cache@v2");
+    if (hasDeploymentTask && needsDocker) {
+        lines.push("      - uses: docker/setup-buildx-action@v3", "        if: matrix.check == 'deployment'");
     }
+    if (requiresRustToolchain)
+        lines.push(...rustCiPreparationLines());
     lines.push(`      - run: ${taskLayer.installCommand}`);
-    lines.push(...options.checkPlan.environmentNeeds.map((need) => `      - run: ${renderCiEnvironmentNeedCommand(need)}`));
+    const checkEnvironmentLines = [];
+    for (const need of options.environment.needs) {
+        if (need.kind === "rust-toolchain") {
+            continue;
+        }
+        checkEnvironmentLines.push(`      - run: ${renderCiEnvironmentNeedCommand(need)}`);
+        if (hasDeploymentTask && need.kind === "shellcheck-command") {
+            checkEnvironmentLines.push("        if: matrix.check == 'root'");
+        }
+    }
+    lines.push(...checkEnvironmentLines);
     lines.push(`      - run: ${taskLayer.checkCommand}`);
-    const deploymentCheck = deploymentChecks[0];
-    if (deploymentCheck !== undefined) {
-        lines.push(`      - run: pnpm run ${deploymentCheckTaskName(deploymentCheck)}`);
+    if (hasDeploymentTask) {
+        lines.push("        if: matrix.check == 'root'");
+    }
+    if (hasDeploymentTask) {
+        lines.push("      - run: pnpm run check:deployment", "        if: matrix.check == 'deployment'");
     }
     lines.push("");
     return lines.join("\n");
 }
+function rustCiPreparationLines() {
+    return [
+        "      - uses: dtolnay/rust-toolchain@stable",
+        "        with:",
+        "          components: rustfmt, clippy",
+        "      - uses: Swatinem/rust-cache@v2",
+    ];
+}
+/** Limited substitutions for the Foundation-owned workflow Template Source. */
+export function projectCheckWorkflowTemplateReplacements(options) {
+    const requiresRustToolchain = options.environmentPreparation?.rustToolchain === true ||
+        options.environment.needs.some((need) => need.kind === "rust-toolchain");
+    const hasDeploymentTask = options.hasDeploymentTask === true;
+    const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
+    const environmentSteps = options.environment.needs
+        .filter((need) => need.kind !== "rust-toolchain")
+        .map((need) => [
+        `      - run: ${renderCiEnvironmentNeedCommand(need)}`,
+        ...(hasDeploymentTask && need.kind === "shellcheck-command"
+            ? ["        if: matrix.check == 'root'"]
+            : []),
+    ].join("\n"));
+    return {
+        RUST_CI_PREPARATION: requiresRustToolchain
+            ? `\n${rustCiPreparationLines().join("\n")}`
+            : "",
+        CHECK_ENVIRONMENT_PREPARATION: environmentSteps.length === 0 ? "" : `\n${environmentSteps.join("\n")}`,
+        DEPLOYMENT_MATRIX: hasDeploymentTask
+            ? "\n    strategy:\n      matrix:\n        check: [root, deployment]"
+            : "",
+        DEPLOYMENT_DOCKER_PREPARATION: hasDeploymentTask && needsDocker
+            ? "\n      - uses: docker/setup-buildx-action@v3\n        if: matrix.check == 'deployment'"
+            : "",
+        ROOT_CHECK_CONDITION: hasDeploymentTask
+            ? "\n        if: matrix.check == 'root'"
+            : "",
+        DEPLOYMENT_CHECK: hasDeploymentTask
+            ? "\n      - run: pnpm run check:deployment\n        if: matrix.check == 'deployment'"
+            : "",
+    };
+}
 export function projectDependabotConfig(policy) {
     return [
         "version: 2",
@@ -65,6 +122,15 @@ export function projectDependabotConfig(policy) {
         "",
     ].join("\n");
 }
+/** Limited substitution for the Foundation-owned Dependabot Template Source. */
+export function projectDependabotTemplateReplacements(policy) {
+    const header = "version: 2\n\nupdates:\n";
+    const configuration = projectDependabotConfig(policy);
+    if (!configuration.startsWith(header)) {
+        throw new Error("Dependabot configuration must retain its Template Source header");
+    }
+    return { DEPENDABOT_UPDATES: configuration.slice(header.length).trimEnd() };
+}
 function renderDependabotUpdate(ecosystem, directory, interval) {
     const lines = [
         `  - package-ecosystem: ${ecosystem}`,
@@ -73,7 +139,7 @@ function renderDependabotUpdate(ecosystem, directory, interval) {
         `      interval: ${interval}`,
     ];
     if (ecosystem === "npm") {
-        lines.push("    groups:", "      drizzle:", "        patterns:", '          - "drizzle-*"', '          - "drizzle-orm"', "    ignore:", '      - dependency-name: "@types/node"', "        update-types:", "          - version-update:semver-major");
+        lines.push("    groups:", "      drizzle:", "        patterns:", '          - "drizzle-*"', '          - "drizzle-orm"', "    ignore:", '      - dependency-name: "@types/node"', "        update-types:", "          - version-update:semver-major", '      - dependency-name: "pnpm"', "        update-types:", "          - version-update:semver-major", "          - version-update:semver-minor", "          - version-update:semver-patch");
     }
     if (ecosystem === "docker" && directory === "/.devcontainer") {
         lines.push("    ignore:", "      - dependency-name: mcr.microsoft.com/devcontainers/typescript-node", "        update-types:", "          - version-update:semver-major");
@@ -87,5 +153,12 @@ function defaultDependabotDirectory(ecosystem) {
     return ecosystem === "docker" ? "/.devcontainer" : "/";
 }
 function renderCiEnvironmentNeedCommand(need) {
-    return renderPlaywrightBrowserInstallCommand(need, { withDeps: true });
+    switch (need.kind) {
+        case "playwright-browser-assets":
+            return renderPlaywrightBrowserInstallCommand(need, { withDeps: true });
+        case "shellcheck-command":
+            return need.nextStep.display;
+        case "rust-toolchain":
+            return need.nextStep.display;
+    }
 }

package/node_modules/@ykdz/template-core/dist/project-linking-v2.d.ts

@@ -0,0 +1,20 @@
+import type { PackageContribution } from "./package-contribution.ts";
+import { type ProjectBlueprintV2 } from "./project-blueprint-v2.ts";
+export type ExplicitProjectLinkPlan = {
+    readonly manifestDependenciesByPackagePath: ReadonlyMap<string, Readonly<Record<string, "workspace:*">>>;
+    /**
+     * Build ordering follows the same explicit package relationships as manifest
+     * dependencies. Turbo resolves ^build through the derived workspace
+     * dependency rather than through Preset or framework vocabulary.
+     */
+    readonly hasBuildOrdering: boolean;
+};
+/**
+ * Resolves durable Link Intents using the explicit exposures supplied by
+ * Package Contributions. No Preset identity or string resource protocol is
+ * involved.
+ */
+export declare function planExplicitProjectLinks(options: {
+    readonly blueprint: ProjectBlueprintV2;
+    readonly contributions: readonly PackageContribution[];
+}): ExplicitProjectLinkPlan;

package/node_modules/@ykdz/template-core/dist/project-linking-v2.js

@@ -0,0 +1,37 @@
+import { assertProjectBlueprintV2, } from "./project-blueprint-v2.js";
+/**
+ * Resolves durable Link Intents using the explicit exposures supplied by
+ * Package Contributions. No Preset identity or string resource protocol is
+ * involved.
+ */
+export function planExplicitProjectLinks(options) {
+    const blueprint = assertProjectBlueprintV2(options.blueprint);
+    const contributionsByPath = new Map(options.contributions.map((contribution) => [
+        contribution.definition.path,
+        contribution,
+    ]));
+    const dependencies = new Map();
+    for (const intent of blueprint.packageLinkIntents ?? []) {
+        const provider = contributionsByPath.get(intent.providerPackagePath);
+        const consumer = contributionsByPath.get(intent.consumerPackagePath);
+        if (provider === undefined || consumer === undefined) {
+            throw new Error("Project Linking requires explicit Package Contributions for every Link Intent endpoint");
+        }
+        if (Object.keys(provider.exposure.exports).length === 0) {
+            throw new Error(`Package Link provider ${provider.definition.path} has no Package Exposure`);
+        }
+        const consumerDependencies = dependencies.get(intent.consumerPackagePath);
+        if (consumerDependencies === undefined) {
+            dependencies.set(intent.consumerPackagePath, {
+                [provider.definition.name]: "workspace:*",
+            });
+        }
+        else {
+            consumerDependencies[provider.definition.name] = "workspace:*";
+        }
+    }
+    return {
+        manifestDependenciesByPackagePath: dependencies,
+        hasBuildOrdering: dependencies.size > 0,
+    };
+}

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

@@ -1,60 +1,95 @@
 type RenderVariables = Record<string, string>;
+export type RenderOperationProvenance = {
+    readonly definitionName: string;
+    readonly plannerSourceFile: string;
+    readonly planningContribution: string;
+    readonly ownershipRule: string;
+};
+/**
+ * An opaque, owned Template Source reference.  A renderer operation carries
+ * this directly instead of selecting a root from a string-keyed side map.
+ */
+declare const templateSourceHandleBrand: unique symbol;
+export type TemplateSourceHandle = {
+    readonly [templateSourceHandleBrand]: true;
+};
+export declare function createTemplateSourceHandle(root: string): TemplateSourceHandle;
+/** Resolves a handle-owned source path while enforcing containment. */
+export declare function resolveTemplateSource(source: TemplateSourceHandle, relativePath: string): string;
 export type CopyFileOperation = {
     kind: "copyFile";
     from: string;
     to: string;
-    sourceRoot?: string;
+    source: TemplateSourceHandle;
+    /** Foundation refreshes coordinated outputs during Package Addition. */
+    overwrite?: boolean;
+    provenance?: RenderOperationProvenance;
 };
 export type WriteJsonOperation = {
     kind: "writeJson";
     to: string;
     value: unknown;
     multilineArrays?: string[];
+    overwrite?: boolean;
+    provenance?: RenderOperationProvenance;
 };
 export type MergeJsonOperation = {
     kind: "mergeJson";
     to: string;
     value: unknown;
+    multilineArrays?: string[];
+    provenance?: RenderOperationProvenance;
 };
 export type WriteTextOperation = {
     kind: "writeText";
     to: string;
     text: string;
+    provenance?: RenderOperationProvenance;
 };
 export type WriteTextFromFragmentsOperation = {
     kind: "writeTextFromFragments";
     to: string;
     fragments: readonly {
         from: string;
-        sourceRoot?: string;
+        source: TemplateSourceHandle;
     }[];
+    overwrite?: boolean;
+    provenance?: RenderOperationProvenance;
 };
 export type WriteTextTemplateOperation = {
     kind: "writeTextTemplate";
     from: string;
     to: string;
-    sourceRoot?: string;
+    source: TemplateSourceHandle;
     replacements: Record<string, string>;
+    /** Follow-up plans may refresh a coordinated template-owned file. */
+    overwrite?: boolean;
+    provenance?: RenderOperationProvenance;
 };
 export type SetExecutableOperation = {
     kind: "setExecutable";
     path: string;
     executable: boolean;
+    provenance?: RenderOperationProvenance;
 };
 export type ReplaceAnchorsOperation = {
     kind: "replaceAnchors";
     path: string;
     language: "typescript";
     replacements: Record<string, string>;
+    provenance?: RenderOperationProvenance;
 };
 export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation | ReplaceAnchorsOperation;
 export type RenderProjectOptions = {
-    sourceRoot: string;
-    sourceRoots?: Record<string, string> | undefined;
     targetRoot: string;
     variables?: RenderVariables | undefined;
     operations: RenderOperation[];
 };
 export declare function renderProject(options: RenderProjectOptions): Promise<void>;
+/**
+ * Applies a follow-up plan in a sibling staging directory.  In particular,
+ * metadata updates cannot become visible when a later source operation fails.
+ */
+export declare function renderProjectAtomically(options: RenderProjectOptions): Promise<void>;
 export declare function renderNewProject(options: RenderProjectOptions): Promise<void>;
 export {};

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>;