@ykdz/template 0.0.33 → 0.0.36

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

@@ -0,0 +1,271 @@
+import { isBuiltin } from "node:module";
+import * as v from "valibot";
+/**
+ * The durable, preset-agnostic topology used by local template follow-up
+ * operations. Preset provenance deliberately belongs in Generation Record.
+ */
+const packageRoles = [
+    "cli-tool",
+    "runtime-service",
+    "shared-library",
+    "native-package",
+];
+const packagePath = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+const reservedWorkspaceCollections = new Set([
+    ".git",
+    ".github",
+    ".devcontainer",
+    ".template",
+    "node_modules",
+    "dist",
+    "target",
+]);
+const reservedPackageNames = new Set(["node_modules", "favicon.ico"]);
+const unknownBlueprintField = "Unknown Blueprint v3 field";
+const packageDefinitionEntries = {
+    name: v.string("Package name must be a string"),
+    path: v.string("Package Path must be a string"),
+    role: v.picklist(packageRoles, "Package Role must be cli-tool, runtime-service, shared-library, or native-package"),
+};
+function packageDefinitionMessage(issue) {
+    return issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
+        ? unknownBlueprintField
+        : "Package Definition must be an object";
+}
+const packageDefinitionSchema = v.strictObject({
+    packageDefinitionId: v.string("Package Definition ID must use the package-<sha256> format"),
+    ...packageDefinitionEntries,
+}, packageDefinitionMessage);
+const packageLinkIntentSchema = v.strictObject({
+    consumerPackagePath: v.string("Package Link Intent consumer Package Path must be a string"),
+    providerPackagePath: v.string("Package Link Intent provider Package Path must be a string"),
+}, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
+    ? unknownBlueprintField
+    : "Package Link Intent must be an object");
+const projectBlueprintSchema = v.strictObject({
+    schemaVersion: v.literal(3, (issue) => `Unsupported Local Template Metadata schema version ${String(issue.input)}; expected 3`),
+    packages: v.array(packageDefinitionSchema, "Package Definitions must be an array"),
+    packageLinkIntents: v.optional(v.array(packageLinkIntentSchema, "Package Link Intents must be an array")),
+}, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
+    ? unknownBlueprintField
+    : "Local Template Metadata must be an object");
+/** Canonical npm package-name predicate shared by Blueprint and input preparation. */
+export function isValidNewNpmPackageName(value) {
+    if (value.length === 0 ||
+        value.length > 214 ||
+        value !== value.trim() ||
+        value !== value.toLowerCase() ||
+        value === "." ||
+        value === ".." ||
+        reservedPackageNames.has(value) ||
+        isBuiltin(value)) {
+        return false;
+    }
+    const scopedMatch = /^@([^/]+)\/([^/]+)$/.exec(value);
+    if (value.startsWith("@") && scopedMatch === null)
+        return false;
+    const scope = scopedMatch?.[1];
+    const leaf = scopedMatch?.[2] ?? value;
+    if (scope === undefined && /^[._-]/.test(leaf)) {
+        return false;
+    }
+    if (scope !== undefined && leaf.startsWith(".")) {
+        return false;
+    }
+    if (/[~'!()*]/.test(leaf))
+        return false;
+    return (encodeURIComponent(leaf) === leaf &&
+        (scope === undefined || encodeURIComponent(scope) === scope));
+}
+/** Canonical Package Path facts shared by Blueprint and input preparation. */
+export function validateNewPackagePath(value) {
+    const workspaceCollection = value.split("/", 1)[0];
+    return {
+        hasValidShape: packagePath.test(value),
+        ...(reservedWorkspaceCollections.has(workspaceCollection)
+            ? { reservedWorkspaceCollection: workspaceCollection }
+            : {}),
+    };
+}
+function blueprintIssuePath(issue) {
+    let result = ".";
+    for (const item of issue.path ?? []) {
+        if (typeof item.key === "number") {
+            result += `[${item.key}]`;
+        }
+        else if (typeof item.key === "string") {
+            result += `${result === "." ? "" : "."}${item.key}`;
+        }
+    }
+    return result;
+}
+function blueprintStructureMessage(issue) {
+    if (issue.type !== "strict_object" ||
+        issue.path?.at(-1)?.origin !== "key" ||
+        issue.input !== undefined) {
+        return issue.message;
+    }
+    const path = blueprintIssuePath(issue);
+    if (path === ".schemaVersion") {
+        return "Unsupported Local Template Metadata schema version undefined; expected 3";
+    }
+    if (path === ".packages")
+        return "Package Definitions must be an array";
+    if (path.endsWith(".name"))
+        return "Package name must be a string";
+    if (path.endsWith(".packageDefinitionId")) {
+        return "Package Definition ID must use the package-<sha256> format";
+    }
+    if (path.endsWith(".path"))
+        return "Package Path must be a string";
+    if (path.endsWith(".role")) {
+        return "Package Role must be cli-tool, runtime-service, shared-library, or native-package";
+    }
+    if (path === ".packageLinkIntents") {
+        return "Package Link Intents must be an array";
+    }
+    if (path.endsWith(".consumerPackagePath")) {
+        return "Package Link Intent consumer Package Path must be a string";
+    }
+    if (path.endsWith(".providerPackagePath")) {
+        return "Package Link Intent provider Package Path must be a string";
+    }
+    return issue.message;
+}
+function validateBlueprintTopologySemantics(blueprint) {
+    const issues = [];
+    for (const [index, definition] of blueprint.packages.entries()) {
+        const itemPath = `.packages[${index}]`;
+        const pathValidation = validateNewPackagePath(definition.path);
+        if (!isValidNewNpmPackageName(definition.name)) {
+            issues.push({
+                path: `${itemPath}.name`,
+                message: "Package name must be a valid npm package name for new packages",
+            });
+        }
+        if (pathValidation.reservedWorkspaceCollection !== undefined) {
+            issues.push({
+                path: `${itemPath}.path`,
+                message: `Package Path ${definition.path} uses reserved workspace collection ${pathValidation.reservedWorkspaceCollection}`,
+            });
+        }
+        else if (!pathValidation.hasValidShape) {
+            issues.push({
+                path: `${itemPath}.path`,
+                message: "Package Path must be exactly two safe path segments",
+            });
+        }
+    }
+    for (const [property, label] of [
+        ["name", "Package name"],
+        ["path", "Package Path"],
+    ]) {
+        const seen = new Set();
+        for (const definition of blueprint.packages) {
+            const member = definition[property];
+            if (seen.has(member)) {
+                issues.push({
+                    path: ".packages",
+                    message: `${label} must be unique: ${member}`,
+                });
+            }
+            seen.add(member);
+        }
+    }
+    const paths = new Set(blueprint.packages.map((definition) => definition.path));
+    const links = new Set();
+    for (const [index, intent] of (blueprint.packageLinkIntents ?? []).entries()) {
+        const itemPath = `.packageLinkIntents[${index}]`;
+        if (!paths.has(intent.consumerPackagePath)) {
+            issues.push({
+                path: `${itemPath}.consumerPackagePath`,
+                message: "Package Link Intent references an unknown consumer package",
+            });
+        }
+        if (!paths.has(intent.providerPackagePath)) {
+            issues.push({
+                path: `${itemPath}.providerPackagePath`,
+                message: "Package Link Intent references an unknown provider package",
+            });
+        }
+        if (intent.consumerPackagePath === intent.providerPackagePath) {
+            issues.push({
+                path: itemPath,
+                message: "Package Link Intent cannot link a package to itself",
+            });
+        }
+        const key = `${intent.consumerPackagePath}\u0000${intent.providerPackagePath}`;
+        if (links.has(key)) {
+            issues.push({
+                path: itemPath,
+                message: "Package Link Intent must be unique",
+            });
+        }
+        links.add(key);
+    }
+    return issues;
+}
+function validatePersistedPackageIds(blueprint) {
+    const issues = [];
+    const seen = new Set();
+    for (const [index, definition] of blueprint.packages.entries()) {
+        if (!/^package-[a-f0-9]{64}$/.test(definition.packageDefinitionId)) {
+            issues.push({
+                path: `.packages[${index}].packageDefinitionId`,
+                message: "Package Definition ID must use the package-<sha256> format",
+            });
+        }
+        if (seen.has(definition.packageDefinitionId)) {
+            issues.push({
+                path: ".packages",
+                message: `Package Definition ID must be unique: ${definition.packageDefinitionId}`,
+            });
+        }
+        seen.add(definition.packageDefinitionId);
+    }
+    return issues;
+}
+/** Validates persisted metadata before it is used to plan or render changes. */
+export function validateProjectBlueprint(value) {
+    const parsed = v.safeParse(projectBlueprintSchema, value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            issues: parsed.issues.map((issue) => ({
+                path: blueprintIssuePath(issue),
+                message: blueprintStructureMessage(issue),
+            })),
+        };
+    }
+    const blueprint = {
+        schemaVersion: parsed.output.schemaVersion,
+        packages: parsed.output.packages,
+        ...(parsed.output.packageLinkIntents === undefined
+            ? {}
+            : { packageLinkIntents: parsed.output.packageLinkIntents }),
+    };
+    const issues = [
+        ...validateBlueprintTopologySemantics(blueprint),
+        ...validatePersistedPackageIds(blueprint),
+    ];
+    return issues.length === 0
+        ? { ok: true, value: blueprint }
+        : { ok: false, issues };
+}
+/** Validates preset-owned topology before any persisted identity is assigned. */
+export function assertProjectBlueprintDraft(value) {
+    const issues = validateBlueprintTopologySemantics(value);
+    if (issues.length > 0) {
+        throw new Error(issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n"));
+    }
+    return value;
+}
+export function assertProjectBlueprint(value) {
+    const result = validateProjectBlueprint(value);
+    if (!result.ok) {
+        throw new Error(result.issues
+            .map((issue) => `${issue.path}: ${issue.message}`)
+            .join("\n"));
+    }
+    return result.value;
+}

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

@@ -1,5 +1,5 @@
 import type { PackageContribution } from "./package-contribution.ts";
-import { type PackageRole, type ProjectBlueprintV2 } from "./project-blueprint-v2.ts";
+import { type PackageRole, type ProjectBlueprint } from "./project-blueprint.ts";
 type PackageManifest = Readonly<Record<string, unknown>>;
 export type ExplicitProjectLinkPlan = {
     readonly manifestPatchesByPackagePath: ReadonlyMap<string, {
@@ -24,7 +24,7 @@ export declare function canProvideSourceConditionPackageNameImport(contribution:
  * string resource protocol is involved.
  */
 export declare function planExplicitProjectLinks(options: {
-    readonly blueprint: ProjectBlueprintV2;
+    readonly blueprint: ProjectBlueprint;
     readonly contributions: readonly PackageContribution[];
     readonly manifestTruthByPackagePath?: ReadonlyMap<string, PackageManifest>;
 }): ExplicitProjectLinkPlan;

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

@@ -1,4 +1,4 @@
-import { assertProjectBlueprintV2, } from "./project-blueprint-v2.js";
+import { assertProjectBlueprint, } from "./project-blueprint.js";
 export function canConsumeNodePackageNameImport(contribution, manifest = contribution.manifest) {
     return (contribution.definition.role !== "native-package" &&
         manifest.type === "module");
@@ -74,7 +74,7 @@ function exposesImportablePackageRoot(manifest) {
  * string resource protocol is involved.
  */
 export function planExplicitProjectLinks(options) {
-    const blueprint = assertProjectBlueprintV2(options.blueprint);
+    const blueprint = assertProjectBlueprint(options.blueprint);
     const contributionsByPath = new Map(options.contributions.map((contribution) => [
         contribution.definition.path,
         contribution,

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

@@ -87,9 +87,10 @@ export type ProjectProjectionAction = {
 };
 export type MaterializeProjectProjectionOptions = {
     readonly operations: readonly RenderOperation[];
-    readonly variables?: Readonly<Record<string, string>>;
     readonly reconciliation?: readonly ProjectProjectionReconciliation[];
 };
+/** Pure structural preflight for a renderer-facing Project Projection plan. */
+export declare function validateProjectProjectionPlan(options: MaterializeProjectProjectionOptions): readonly string[];
 export declare function reconcileProjectProjections(options: {
     readonly before: ProjectProjection;
     readonly after: ProjectProjection;

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

@@ -11,30 +11,18 @@ class ProjectProjectionPathPreconditionError extends Error {
         this.conflicts = conflicts;
     }
 }
-function expandTemplatePath(templatePath, variables) {
-    return templatePath.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/gu, (_placeholder, name) => {
-        const value = variables[name];
-        if (!value)
-            throw new Error(`Missing renderer variable: ${name}`);
-        if (!/^[A-Za-z0-9._-]+$/u.test(value)) {
-            throw new Error(`Renderer variable ${name} is not safe for a path segment`);
-        }
-        return value;
-    });
-}
-function normalizedOutputPath(operation, variables) {
+function normalizedOutputPath(operation) {
     const operationPath = operation.kind === "setExecutable" || operation.kind === "replaceAnchors"
         ? operation.path
         : operation.to;
-    const expanded = expandTemplatePath(operationPath, variables);
-    if (path.isAbsolute(expanded)) {
-        throw new Error(`Project Projection paths must be relative: ${expanded}`);
+    if (path.isAbsolute(operationPath)) {
+        throw new Error(`Project Projection paths must be relative: ${operationPath}`);
     }
-    const normalized = path.posix.normalize(expanded.split(path.sep).join("/"));
+    const normalized = path.posix.normalize(operationPath.split(path.sep).join("/"));
     if (normalized === "." ||
         normalized === ".." ||
         normalized.startsWith("../")) {
-        throw new Error(`Project Projection path escapes its root: ${expanded}`);
+        throw new Error(`Project Projection path escapes its root: ${operationPath}`);
     }
     return normalized;
 }
@@ -55,6 +43,103 @@ function operationDriver(operation) {
             return undefined;
     }
 }
+/** Pure structural preflight for a renderer-facing Project Projection plan. */
+export function validateProjectProjectionPlan(options) {
+    const diagnostics = [];
+    const contentKindByPath = new Map();
+    const contentTypeByPath = new Map();
+    const transformationKindByPath = new Map();
+    const finalPaths = new Set();
+    for (const operation of options.operations) {
+        let outputPath;
+        try {
+            outputPath = normalizedOutputPath(operation);
+        }
+        catch (error) {
+            diagnostics.push(error instanceof Error ? error.message : String(error));
+            continue;
+        }
+        finalPaths.add(outputPath);
+        const precedingKind = contentKindByPath.get(outputPath);
+        if (operation.kind === "setExecutable" ||
+            operation.kind === "replaceAnchors") {
+            if (precedingKind === undefined) {
+                diagnostics.push(`Project Projection ${operation.kind} requires a preceding content-producing operation: ${outputPath}`);
+            }
+            const hasCompatibleContent = operation.kind !== "replaceAnchors" ||
+                contentTypeByPath.get(outputPath) !== "json";
+            if (!hasCompatibleContent) {
+                diagnostics.push(`Project Projection replaceAnchors requires text-compatible content: ${outputPath} follows ${precedingKind}`);
+            }
+            if (precedingKind !== undefined && hasCompatibleContent) {
+                if (operation.kind === "replaceAnchors") {
+                    contentTypeByPath.set(outputPath, "text");
+                }
+                transformationKindByPath.set(outputPath, operation.kind);
+            }
+            continue;
+        }
+        if (operation.kind === "mergeJson" ||
+            operation.kind === "mergeJsonTemplate") {
+            const transformationKind = transformationKindByPath.get(outputPath);
+            if (transformationKind !== undefined) {
+                diagnostics.push(`Project Projection ${operation.kind} may not overwrite content after ${transformationKind}: ${outputPath}`);
+            }
+            if (contentTypeByPath.get(outputPath) === "text") {
+                diagnostics.push(`Project Projection ${operation.kind} requires JSON-compatible content: ${outputPath} follows ${precedingKind}`);
+            }
+            if (precedingKind === undefined) {
+                contentKindByPath.set(outputPath, operation.kind);
+            }
+            contentTypeByPath.set(outputPath, "json");
+            transformationKindByPath.delete(outputPath);
+            continue;
+        }
+        const overwrite = "overwrite" in operation && operation.overwrite;
+        const transformationKind = transformationKindByPath.get(outputPath);
+        if (overwrite && transformationKind !== undefined) {
+            diagnostics.push(`Project Projection ${operation.kind} may not overwrite content after ${transformationKind}: ${outputPath}`);
+        }
+        if (precedingKind !== undefined && !overwrite) {
+            diagnostics.push(`Project Projection collision at ${outputPath}: ${operation.kind} follows ${precedingKind} without overwrite`);
+        }
+        contentKindByPath.set(outputPath, operation.kind);
+        if (operation.kind === "writeJson") {
+            contentTypeByPath.set(outputPath, "json");
+        }
+        else if (operation.kind === "writeText") {
+            try {
+                JSON.parse(operation.text);
+                contentTypeByPath.set(outputPath, "json");
+            }
+            catch {
+                contentTypeByPath.set(outputPath, "text");
+            }
+        }
+        else {
+            contentTypeByPath.set(outputPath, "unknown");
+        }
+        transformationKindByPath.delete(outputPath);
+    }
+    const orderedPaths = [...finalPaths].toSorted();
+    for (const candidate of orderedPaths) {
+        const ancestor = orderedPaths.find((other) => other !== candidate && candidate.startsWith(`${other}/`));
+        if (ancestor !== undefined) {
+            diagnostics.push(`Project Projection path collision: file ${ancestor} is an ancestor of ${candidate}`);
+        }
+    }
+    const reconciliationPaths = new Set();
+    for (const reconciliation of options.reconciliation ?? []) {
+        if (reconciliationPaths.has(reconciliation.path)) {
+            diagnostics.push(`Project Projection reconciliation paths must be unique: ${reconciliation.path}`);
+        }
+        else if (!finalPaths.has(reconciliation.path)) {
+            diagnostics.push(`Project Projection reconciliation references an unknown path: ${reconciliation.path}`);
+        }
+        reconciliationPaths.add(reconciliation.path);
+    }
+    return diagnostics;
+}
 function bytesEqual(left, right) {
     return (left.byteLength === right.byteLength &&
         left.every((value, index) => value === right[index]));
@@ -1031,12 +1116,15 @@ export function createProjectProjectionReconciler(dependencies = {}) {
 }
 export const reconcileAndApplyProjectProjections = createProjectProjectionReconciler();
 export async function materializeProjectProjection(options) {
-    const variables = options.variables ?? {};
+    const planDiagnostics = validateProjectProjectionPlan(options);
+    if (planDiagnostics.length > 0) {
+        throw new Error(planDiagnostics.join("\n"));
+    }
     const finalPaths = new Set();
     const contentPaths = new Set();
     const policies = new Map();
     for (const operation of options.operations) {
-        const outputPath = normalizedOutputPath(operation, variables);
+        const outputPath = normalizedOutputPath(operation);
         finalPaths.add(outputPath);
         if (operation.kind === "setExecutable") {
             if (!contentPaths.has(outputPath)) {
@@ -1067,7 +1155,6 @@ export async function materializeProjectProjection(options) {
     try {
         await renderProject({
             targetRoot,
-            variables: { ...variables },
             operations: [...options.operations],
         });
         const entries = await Promise.all([...finalPaths].toSorted().map(async (relativePath) => {

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

@@ -1,4 +1,3 @@
-type RenderVariables = Record<string, string>;
 export type RenderOperationProvenance = {
     readonly definitionName: string;
     readonly plannerSourceFile: string;
@@ -96,7 +95,6 @@ export type ReplaceAnchorsOperation = {
 export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | MergeJsonTemplateOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation | ReplaceAnchorsOperation;
 export type RenderProjectOptions = {
     targetRoot: string;
-    variables?: RenderVariables | undefined;
     operations: RenderOperation[];
 };
 export declare function renderProject(options: RenderProjectOptions): Promise<void>;

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

@@ -24,18 +24,6 @@ export function resolveTemplateSource(source, relativePath) {
     }
     return resolveContainedPath(root, relativePath);
 }
-function expandTemplatePath(templatePath, variables) {
-    return templatePath.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_, name) => {
-        const value = variables[name];
-        if (!value) {
-            throw new Error(`Missing renderer variable: ${name}`);
-        }
-        if (!/^[A-Za-z0-9._-]+$/.test(value)) {
-            throw new Error(`Renderer variable ${name} is not safe for a path segment`);
-        }
-        return value;
-    });
-}
 function resolveContainedPath(root, relativePath) {
     if (path.isAbsolute(relativePath)) {
         throw new Error(`Renderer paths must be relative: ${relativePath}`);
@@ -49,13 +37,9 @@ function resolveContainedPath(root, relativePath) {
     }
     return resolvedPath;
 }
-function expandOperationPath(relativePath, options) {
-    return expandTemplatePath(relativePath, options.variables ?? {});
-}
 async function renderCopyFile(operation, options) {
-    const variables = options.variables ?? {};
-    const from = resolveTemplateSource(operation.source, expandTemplatePath(operation.from, variables));
-    const to = resolveContainedPath(options.targetRoot, expandTemplatePath(operation.to, variables));
+    const from = resolveTemplateSource(operation.source, operation.from);
+    const to = resolveContainedPath(options.targetRoot, operation.to);
     const sourceMode = (await stat(from)).mode;
     await mkdir(path.dirname(to), { recursive: true });
     await copyGeneratedFile(from, to, operation.overwrite ?? false);
@@ -126,21 +110,20 @@ async function writeJsonFile(targetRoot, toPath, value, multilineArrays, keyOrde
         : new Map(nestedKeyOrder.map((key, index) => [key, index]))), overwrite);
 }
 async function renderWriteJson(operation, options) {
-    await writeJsonFile(options.targetRoot, expandOperationPath(operation.to, options), operation.value, operation.multilineArrays, operation.keyOrder, operation.nestedKeyOrder, operation.overwrite);
+    await writeJsonFile(options.targetRoot, operation.to, operation.value, operation.multilineArrays, operation.keyOrder, operation.nestedKeyOrder, operation.overwrite);
 }
 async function renderMergeJson(operation, options) {
     await mergeJsonIntoFile({
         options,
         patch: operation.value,
-        toPath: expandOperationPath(operation.to, options),
+        toPath: operation.to,
         multilineArrays: operation.multilineArrays,
         keyOrder: operation.keyOrder,
         nestedKeyOrder: operation.nestedKeyOrder,
     });
 }
 async function renderMergeJsonTemplate(operation, options) {
-    const variables = options.variables ?? {};
-    const sourcePath = resolveTemplateSource(operation.source, expandTemplatePath(operation.from, variables));
+    const sourcePath = resolveTemplateSource(operation.source, operation.from);
     let patch;
     try {
         patch = JSON.parse(await readFile(sourcePath, "utf8"));
@@ -151,7 +134,7 @@ async function renderMergeJsonTemplate(operation, options) {
     await mergeJsonIntoFile({
         options,
         patch,
-        toPath: expandOperationPath(operation.to, options),
+        toPath: operation.to,
         multilineArrays: operation.multilineArrays,
         keyOrder: operation.keyOrder,
         nestedKeyOrder: operation.nestedKeyOrder,
@@ -171,16 +154,14 @@ async function mergeJsonIntoFile(options) {
     await writeJsonFile(options.options.targetRoot, options.toPath, mergeJsonValue(existing, options.patch), options.multilineArrays, options.keyOrder, options.nestedKeyOrder, true);
 }
 async function renderWriteText(operation, options) {
-    const toPath = expandOperationPath(operation.to, options);
-    const to = resolveContainedPath(options.targetRoot, toPath);
+    const to = resolveContainedPath(options.targetRoot, operation.to);
     await mkdir(path.dirname(to), { recursive: true });
     await writeGeneratedFile(to, operation.text);
 }
-async function loadTextFragments(operation, options) {
+async function loadTextFragments(operation) {
     return Promise.all(operation.fragments.map(async (fragment) => {
-        const fromPath = expandTemplatePath(fragment.from, options.variables ?? {});
-        const from = resolveTemplateSource(fragment.source, fromPath);
-        return { from: fromPath, text: await readFile(from, "utf8") };
+        const from = resolveTemplateSource(fragment.source, fragment.from);
+        return { from: fragment.from, text: await readFile(from, "utf8") };
     }));
 }
 async function validateDevelopmentContainerDockerfileOperation(operation, fragments) {
@@ -212,16 +193,15 @@ async function preflightDevelopmentContainerDockerfiles(options) {
             operation.validation !== "development-container-dockerfile") {
             continue;
         }
-        const fragments = await loadTextFragments(operation, options);
+        const fragments = await loadTextFragments(operation);
         await validateDevelopmentContainerDockerfileOperation(operation, fragments);
         loadedFragments.set(operation, fragments);
     }
     return loadedFragments;
 }
 async function renderWriteTextFromFragments(operation, options, preloadedFragments) {
-    const toPath = expandOperationPath(operation.to, options);
-    const to = resolveContainedPath(options.targetRoot, toPath);
-    const fragments = preloadedFragments ?? (await loadTextFragments(operation, options));
+    const to = resolveContainedPath(options.targetRoot, operation.to);
+    const fragments = preloadedFragments ?? (await loadTextFragments(operation));
     await validateDevelopmentContainerDockerfileOperation(operation, fragments);
     await mkdir(path.dirname(to), { recursive: true });
     await writeGeneratedFile(to, fragments.map(({ text }) => text.trimEnd()).join("\n\n") + "\n", operation.overwrite ?? false);
@@ -244,15 +224,14 @@ function replaceTextTemplateVariables(sourceText, replacements) {
     return rendered;
 }
 async function renderWriteTextTemplate(operation, options) {
-    const toPath = expandOperationPath(operation.to, options);
-    const from = resolveTemplateSource(operation.source, expandTemplatePath(operation.from, options.variables ?? {}));
-    const to = resolveContainedPath(options.targetRoot, toPath);
+    const from = resolveTemplateSource(operation.source, operation.from);
+    const to = resolveContainedPath(options.targetRoot, operation.to);
     const sourceText = await readFile(from, "utf8");
     await mkdir(path.dirname(to), { recursive: true });
     await writeGeneratedFile(to, replaceTextTemplateVariables(sourceText, operation.replacements), operation.overwrite);
 }
 async function renderSetExecutable(operation, options) {
-    const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
+    const filePath = resolveContainedPath(options.targetRoot, operation.path);
     const currentMode = (await stat(filePath)).mode;
     const executeBits = 0o111;
     const mode = operation.executable
@@ -314,7 +293,7 @@ async function renderReplaceAnchors(operation, options) {
     if (operation.language !== "typescript") {
         throw new Error("Checked Transform Anchor only supports TypeScript");
     }
-    const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
+    const filePath = resolveContainedPath(options.targetRoot, operation.path);
     const sourceText = await readFile(filePath, "utf8");
     const ranges = await findTypeScriptAnchorRanges(sourceText);
     for (const anchorName of Object.keys(operation.replacements)) {

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

@@ -1,4 +1,4 @@
-import type { ProjectBlueprintV2 } from "./project-blueprint-v2.ts";
+import type { ProjectBlueprint } from "./project-blueprint.ts";
 import { type RenderOperation } from "./renderer.ts";
 export type TemplateBoundaryViolation = {
     readonly preset: string;
@@ -43,7 +43,7 @@ export type CheckTemplateSourceBoundaryOptions = {
         readonly planningContribution?: string;
         readonly generatedPath: ".github/workflows/check.yml";
         /** The original Blueprint, before Foundation composes workflow facts. */
-        readonly blueprint: ProjectBlueprintV2;
+        readonly blueprint: ProjectBlueprint;
         /** Raw Package Contribution declarations, not the composed plan field. */
         readonly diagnosticArtifactDeclarations: readonly unknown[];
         readonly operations: readonly RenderOperation[];

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

@@ -70,6 +70,12 @@ export function isProtectedGeneratedPath(generatedPath) {
         normalizedPath === ".github/dependabot.yml" ||
         normalizedPath.startsWith(".github/workflows/") ||
         normalizedPath.startsWith(".vscode/") ||
+        normalizedPath.startsWith("scripts/npm-publication/") ||
+        normalizedPath.startsWith("scripts/npm-publication-setup/") ||
+        fileName === "CHANGELOG.md" ||
+        fileName === "LICENSE" ||
+        fileName === "README.md" ||
+        fileName === "RELEASING.md" ||
         fileName === "oxfmt.config.ts" ||
         fileName === "oxlint.config.ts" ||
         fileName === "playwright.config.ts" ||

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

@@ -32,4 +32,6 @@ export type OnlineToolchainResolutionContractResult = {
 };
 export declare function resolveToolchainVersions(options?: ResolveToolchainVersionsOptions): Promise<ResolvedToolchainVersions>;
 export declare function checkOnlineToolchainResolutionContract(options?: OnlineToolchainResolutionContractOptions): Promise<OnlineToolchainResolutionContractResult>;
+export declare function isValidNodeLtsMajor(value: string): boolean;
+export declare function isValidPackageManagerPin(value: string): boolean;
 export {};