@ykdz/template 0.0.35 → 0.0.37

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]));
@@ -98,6 +183,63 @@ function reconcileMode(before, current, after) {
 function describeExecutableMode(entry) {
     return entry.mode.toString(8).padStart(3, "0");
 }
+/**
+ * 识别已接受设计中有限的成对锚点词表。
+ * 剥掉注释标点只是为了读出标记本身，这里不解释文件格式、关键字或版本。
+ */
+function textMirrorMarker(line) {
+    const stripped = line
+        .trim()
+        .replace(/^[#;%*/-]+/u, "")
+        .trim();
+    if (stripped === "@end-template-mirror")
+        return { kind: "end" };
+    const start = /^@template-mirror\s+(\S+)$/u.exec(stripped);
+    if (start?.[1] !== undefined)
+        return { kind: "start", name: start[1] };
+    return { kind: "content" };
+}
+/** 定位唯一被拥有的那一行；任何不可用形态都返回 `undefined`。 */
+function locateTextMirrorRegion(lines, name) {
+    const starts = [];
+    for (const [index, line] of lines.entries()) {
+        const marker = textMirrorMarker(line);
+        if (marker.kind === "start" && marker.name === name)
+            starts.push(index);
+    }
+    if (starts.length !== 1)
+        return undefined;
+    const start = starts[0];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const marker = textMirrorMarker(lines[index]);
+        if (marker.kind === "start")
+            return undefined;
+        if (marker.kind !== "end")
+            continue;
+        return index - start === 2
+            ? { contentStart: start + 1, contentEnd: index }
+            : undefined;
+    }
+    return undefined;
+}
+/** Before 是否出现过该名的开始标记：区分槽位真缺席与标记不可解释。 */
+function hasTextMirrorStartMarker(lines, name) {
+    for (const line of lines) {
+        const marker = textMirrorMarker(line);
+        if (marker.kind === "start" && marker.name === name)
+            return true;
+    }
+    return false;
+}
+function escapeRegExpToken(value) {
+    return value.replaceAll(/[.$()*?[\]{}+/|^\\]/gu, String.raw `\$&`);
+}
+/** 有界的承载检查：文件是否仍在赋值或引用这个名称？ */
+function textUsesMirrorSlotName(text, name) {
+    const token = escapeRegExpToken(name);
+    return (new RegExp(`(?:^|[^\\w$])${token}\\s*=`, "u").test(text) ||
+        new RegExp(String.raw `\$\{\s*${token}\s*\}`, "u").test(text));
+}
 function reconcileTextEntry(options) {
     const mode = reconcileMode(options.before, options.current, options.after);
     if (mode === undefined)
@@ -121,7 +263,54 @@ function reconcileTextEntry(options) {
             ],
         };
     }
-    const regions = diff3Merge(textLines(currentText), textLines(beforeText), textLines(afterText), { excludeFalseConflicts: true });
+    const slotConflict = (slot, reason) => ({
+        ok: false,
+        conflicts: [
+            {
+                ...(slot.location.kind === "text-anchor"
+                    ? { location: slot.location.name }
+                    : {}),
+                reason,
+                before: describeEntry(options.before),
+                current: describeEntry(options.current),
+                after: describeEntry(options.after),
+            },
+        ],
+    });
+    const beforeLines = textLines(beforeText);
+    let currentLines = textLines(currentText);
+    for (const slot of options.mirrorSlots) {
+        if (slot.location.kind !== "text-anchor")
+            continue;
+        const name = slot.location.name;
+        const currentRegion = locateTextMirrorRegion(currentLines, name);
+        if (currentRegion === undefined) {
+            if (textUsesMirrorSlotName(currentText, name)) {
+                return slotConflict(slot, `Declared mirror slot ${JSON.stringify(slot.id)} anchor could not be located while the ${JSON.stringify(name)} carrier or reference remains`);
+            }
+            continue;
+        }
+        const beforeRegion = locateTextMirrorRegion(beforeLines, name);
+        if (beforeRegion === undefined) {
+            if (hasTextMirrorStartMarker(beforeLines, name)) {
+                return slotConflict(slot, `Declared mirror slot ${JSON.stringify(slot.id)} anchor in Before could not be located while its markers remain`);
+            }
+            // 模板拥有完整镜像块，标记行也属于该块，因此移除整块后再交既有 diff3。
+            currentLines = [
+                ...currentLines.slice(0, currentRegion.contentStart - 1),
+                ...currentLines.slice(currentRegion.contentEnd + 1),
+            ];
+            continue;
+        }
+        currentLines = [
+            ...currentLines.slice(0, currentRegion.contentStart),
+            ...beforeLines.slice(beforeRegion.contentStart, beforeRegion.contentEnd),
+            ...currentLines.slice(currentRegion.contentEnd),
+        ];
+    }
+    const regions = diff3Merge(currentLines, beforeLines, textLines(afterText), {
+        excludeFalseConflicts: true,
+    });
     const conflicts = regions.flatMap((region) => {
         const conflict = region.conflict;
         if (conflict === undefined)
@@ -382,6 +571,190 @@ function parseStructuredEntry(entry) {
         };
     }
 }
+function describeStructuredValueAt(value) {
+    return describeStructuredValue(value);
+}
+function mirrorSlotParent(root, segments) {
+    if (segments.length === 0)
+        return { found: false };
+    let value = root;
+    for (const segment of segments.slice(0, -1)) {
+        if (isStructuredObject(value) && Object.hasOwn(value, segment)) {
+            value = value[segment];
+            continue;
+        }
+        if (Array.isArray(value) &&
+            /^(?:0|[1-9][0-9]*)$/u.test(segment) &&
+            Number.isSafeInteger(Number(segment)) &&
+            Object.hasOwn(value, Number(segment))) {
+            value = value[Number(segment)];
+            continue;
+        }
+        return { found: false };
+    }
+    return { found: true, parent: value };
+}
+function mirrorSlotValue(root, segments) {
+    const parent = mirrorSlotParent(root, segments);
+    if (!parent.found)
+        return missingStructuredValue;
+    const key = segments[segments.length - 1];
+    if (isStructuredObject(parent.parent)) {
+        return Object.hasOwn(parent.parent, key)
+            ? parent.parent[key]
+            : missingStructuredValue;
+    }
+    if (Array.isArray(parent.parent) &&
+        /^(?:0|[1-9][0-9]*)$/u.test(key) &&
+        Object.hasOwn(parent.parent, Number(key))) {
+        return parent.parent[Number(key)];
+    }
+    return missingStructuredValue;
+}
+/**
+ * 有限的槽位读取：把一个 plan 声明的镜像位置在真实投影里解析成恰好一条标量字符串。
+ * Core 只认识通用位置与值形态（合法 JSON、位置存在、值为字符串、锚点区域恰一行），
+ * 不认识具体生成路径、Node/Rust 语义或 ARG 写法；承载行的解释留给 Checks 层。
+ */
+export function readProjectedMirrorSlotScalar(entry, location) {
+    if (location.kind === "json-pointer") {
+        const parsed = parseStructuredEntry(entry);
+        if (!parsed.ok) {
+            return { ok: false, reason: `槽位文件不是合法 JSON：${parsed.message}` };
+        }
+        let segments;
+        try {
+            segments = parseJsonPointer(location.pointer);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: `JSON Pointer 非法：${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        if (segments.length === 0) {
+            return { ok: false, reason: "镜像槽位不能定位到文档根本身" };
+        }
+        const value = mirrorSlotValue(parsed.value, segments);
+        if (value === missingStructuredValue) {
+            return {
+                ok: false,
+                reason: `声明位置在真实投影中不存在：${location.pointer}`,
+            };
+        }
+        if (typeof value !== "string") {
+            return {
+                ok: false,
+                reason: `镜像槽位的值必须是字符串标量：${location.pointer}`,
+            };
+        }
+        return { ok: true, scalar: value };
+    }
+    const decoded = decodeText(entry.content);
+    if (decoded === undefined) {
+        return { ok: false, reason: "文本锚点所在文件不是合法 UTF-8 文本" };
+    }
+    const lines = textLines(decoded);
+    const region = locateTextMirrorRegion(lines, location.name);
+    if (region === undefined) {
+        return {
+            ok: false,
+            reason: `锚点区域缺失、重复、不成对或含额外正文：${location.name}`,
+        };
+    }
+    // locateTextMirrorRegion 已保证区域内恰好一条承载行。
+    return { ok: true, scalar: lines[region.contentStart] };
+}
+function withoutMirrorSlot(root, segments) {
+    if (segments.length === 0)
+        return root;
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        if (!isStructuredObject(root) || !Object.hasOwn(root, head))
+            return root;
+        const kept = {};
+        for (const [key, value] of Object.entries(root)) {
+            if (key !== head)
+                kept[key] = value;
+        }
+        return kept;
+    }
+    if (isStructuredObject(root) && Object.hasOwn(root, head)) {
+        return {
+            ...root,
+            [head]: withoutMirrorSlot(root[head], rest),
+        };
+    }
+    if (Array.isArray(root) &&
+        /^(?:0|[1-9][0-9]*)$/u.test(head) &&
+        Object.hasOwn(root, Number(head))) {
+        return root.map((member, index) => index === Number(head) ? withoutMirrorSlot(member, rest) : member);
+    }
+    return root;
+}
+function withMirrorSlot(root, segments, value) {
+    if (segments.length === 0)
+        return root;
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        if (isStructuredObject(root) && Object.hasOwn(root, head)) {
+            return { ...root, [head]: value };
+        }
+        if (Array.isArray(root) &&
+            /^(?:0|[1-9][0-9]*)$/u.test(head) &&
+            Object.hasOwn(root, Number(head))) {
+            return root.map((member, index) => index === Number(head) ? value : member);
+        }
+        return root;
+    }
+    if (isStructuredObject(root) && Object.hasOwn(root, head)) {
+        return {
+            ...root,
+            [head]: withMirrorSlot(root[head], rest, value),
+        };
+    }
+    if (Array.isArray(root) &&
+        /^(?:0|[1-9][0-9]*)$/u.test(head) &&
+        Object.hasOwn(root, Number(head))) {
+        return root.map((member, index) => index === Number(head) ? withMirrorSlot(member, rest, value) : member);
+    }
+    return root;
+}
+/**
+ * 把 Current 中每个由 planner 声明的位置改写回 Before。
+ * 归一只改写已存在的位置，绝不新建，所以消费者删掉的槽位在既有合并法则下保持缺席。
+ */
+function normalizeCurrentMirrorSlots(options) {
+    let normalized = options.current;
+    for (const { slot, segments } of options.slots) {
+        const location = structuredLocation(segments);
+        const currentValue = mirrorSlotValue(normalized, segments);
+        if (currentValue === missingStructuredValue)
+            continue;
+        const beforeValue = mirrorSlotValue(options.before, segments);
+        const afterValue = mirrorSlotValue(options.after, segments);
+        const unusable = (side) => ({
+            ok: false,
+            conflict: {
+                location,
+                reason: `Declared mirror slot ${JSON.stringify(slot.id)} holds a non-string ${side} value`,
+                before: describeStructuredValueAt(beforeValue),
+                current: describeStructuredValueAt(currentValue),
+                after: describeStructuredValueAt(afterValue),
+            },
+        });
+        if (typeof currentValue !== "string")
+            return unusable("Current");
+        if (beforeValue === missingStructuredValue) {
+            normalized = withoutMirrorSlot(normalized, segments);
+            continue;
+        }
+        if (typeof beforeValue !== "string")
+            return unusable("Before");
+        normalized = withMirrorSlot(normalized, segments, beforeValue);
+    }
+    return { ok: true, value: normalized };
+}
 function reconcileStructuredEntry(options) {
     const mode = reconcileMode(options.before, options.current, options.after);
     if (mode === undefined)
@@ -405,12 +778,31 @@ function reconcileStructuredEntry(options) {
         return parseConflict("Current", current.message);
     if (!after.ok)
         return parseConflict("After", after.message);
-    const reconciled = reconcileStructuredValue(before.value, current.value, after.value, [], options.identitySets);
+    const slotLocations = options.mirrorSlots.map((slot) => ({
+        slot,
+        segments: slot.location.kind === "json-pointer"
+            ? parseJsonPointer(slot.location.pointer)
+            : [],
+    }));
+    const normalized = normalizeCurrentMirrorSlots({
+        before: before.value,
+        current: current.value,
+        after: after.value,
+        slots: slotLocations,
+    });
+    if (!normalized.ok)
+        return normalized;
+    const reconciled = reconcileStructuredValue(before.value, normalized.value, after.value, [], options.identitySets);
     if (!reconciled.ok)
         return reconciled;
     if (reconciled.value === missingStructuredValue) {
         return { ok: false };
     }
+    if (options.mirrorSlots.length > 0 &&
+        structuredValuesEqual(current.value, reconciled.value) &&
+        options.current.mode === mode) {
+        return { ok: true, skip: true };
+    }
     let content;
     try {
         content = new TextEncoder().encode(`${JSON.stringify(reconciled.value, null, 2)}\n`);
@@ -451,6 +843,34 @@ function assertNormalizedSafeRelativePath(projectionPath, member) {
         throw new Error(`Project Projection ${member} path must be a normalized safe relative path: ${projectionPath || "<empty>"}`);
     }
 }
+function assertMirrorSlots(entry, reconciliation) {
+    const slots = reconciliation.mirrorSlots ?? [];
+    const ids = new Set();
+    for (const slot of slots) {
+        if (slot.id.length === 0 || ids.has(slot.id)) {
+            throw new Error(`Project Projection mirror slot ids must be unique and non-empty: ${entry.path} ${JSON.stringify(slot.id)}`);
+        }
+        ids.add(slot.id);
+        if (reconciliation.driver === "structured") {
+            if (slot.location.kind !== "json-pointer") {
+                throw new Error(`Project Projection structured mirror slots require a JSON Pointer location: ${entry.path} ${slot.id}`);
+            }
+            try {
+                parseJsonPointer(slot.location.pointer);
+            }
+            catch (error) {
+                throw new Error(`Project Projection mirror slot location must be an RFC 6901 JSON Pointer: ${entry.path} ${slot.id} (${error instanceof Error ? error.message : String(error)})`, { cause: error });
+            }
+            continue;
+        }
+        if (slot.location.kind !== "text-anchor") {
+            throw new Error(`Project Projection text mirror slots require a named text anchor: ${entry.path} ${slot.id}`);
+        }
+        if (!/^\S+$/u.test(slot.location.name)) {
+            throw new Error(`Project Projection text mirror slot names must be single non-empty tokens: ${entry.path} ${slot.id}`);
+        }
+    }
+}
 function assertProjectionContract(projection) {
     const paths = new Set();
     for (const entry of projection.entries) {
@@ -478,6 +898,9 @@ function assertProjectionContract(projection) {
             reconciliation.identitySets !== undefined) {
             assertIdentitySetPolicies(projection.entries.find((entry) => entry.path === reconciliation.path), reconciliation);
         }
+        if (reconciliation.driver !== "canonical") {
+            assertMirrorSlots(projection.entries.find((entry) => entry.path === reconciliation.path), reconciliation);
+        }
         policies.set(reconciliation.path, reconciliation);
     }
     for (const projectionPath of paths) {
@@ -487,6 +910,24 @@ function assertProjectionContract(projection) {
     }
     return policies;
 }
+/**
+ * 槽位声明沿既有通用合并接缝只允许单调新增：Before 的每个槽位必须按原序出现在 After 前缀，
+ * After 可追加消费者新增能力所对应的位置。删除、重排或改写既有槽位仍判为策略不兼容。
+ * Core 不理解具体文件名或工具链，只在槽位列表结构上判定。
+ */
+function mirrorSlotsExtendMonotonically(before, after) {
+    const prior = before ?? [];
+    const next = after ?? [];
+    if (prior.length > next.length)
+        return false;
+    for (let index = 0; index < prior.length; index += 1) {
+        if (JSON.stringify(prior[index] ?? null) !==
+            JSON.stringify(next[index] ?? null)) {
+            return false;
+        }
+    }
+    return true;
+}
 function reconciliationPoliciesCompatible(left, right) {
     if (left.path !== right.path ||
         left.driver !== right.driver ||
@@ -498,6 +939,9 @@ function reconciliationPoliciesCompatible(left, right) {
     const rightIdentitySets = right.identitySets ?? [];
     if (leftIdentitySets.length !== rightIdentitySets.length)
         return false;
+    if (!mirrorSlotsExtendMonotonically(left.mirrorSlots, right.mirrorSlots)) {
+        return false;
+    }
     return leftIdentitySets.every((leftPolicy, index) => {
         const rightPolicy = rightIdentitySets[index];
         if (rightPolicy === undefined ||
@@ -611,6 +1055,11 @@ function assertIdentitySetPolicies(entry, reconciliation) {
         }
     }
 }
+function declaredMirrorSlots(policy) {
+    if (policy === undefined || policy.driver === "canonical")
+        return [];
+    return policy.mirrorSlots ?? [];
+}
 export async function reconcileProjectProjections(options) {
     const beforePolicies = assertProjectionContract(options.before);
     const afterPolicies = assertProjectionContract(options.after);
@@ -628,20 +1077,34 @@ export async function reconcileProjectProjections(options) {
             throw new Error(`Project Projection reconciliation policy changed for ${projectionPath}`);
         }
     }
-    const deltaPaths = [
-        ...new Set([...beforeByPath.keys(), ...afterByPath.keys()]),
-    ]
+    const deltaPathSet = new Set([...new Set([...beforeByPath.keys(), ...afterByPath.keys()])]
         .filter((projectionPath) => !entriesEqual(beforeByPath.get(projectionPath), afterByPath.get(projectionPath)))
-        .toSorted();
+        .toSorted());
+    const declaredMirrorPaths = new Set();
+    for (const [projectionPath, policy] of afterPolicies) {
+        if (declaredMirrorSlots(policy).length > 0) {
+            declaredMirrorPaths.add(projectionPath);
+        }
+    }
+    for (const [projectionPath, policy] of beforePolicies) {
+        if (declaredMirrorSlots(policy).length > 0) {
+            declaredMirrorPaths.add(projectionPath);
+        }
+    }
+    const reconcilePaths = [
+        ...new Set([...deltaPathSet, ...declaredMirrorPaths]),
+    ].toSorted();
     const mutations = [];
     const conflicts = [];
-    for (const projectionPath of deltaPaths) {
+    for (const projectionPath of reconcilePaths) {
         const before = beforeByPath.get(projectionPath);
         const after = afterByPath.get(projectionPath);
         const beforePolicy = beforePolicies.get(projectionPath);
         const afterPolicy = afterPolicies.get(projectionPath);
         const policy = afterPolicy ?? beforePolicy;
         const driver = policy.driver;
+        const mirrorSlots = declaredMirrorSlots(policy);
+        const isDeltaPath = deltaPathSet.has(projectionPath);
         const current = await options.readCurrent(projectionPath);
         if (entriesEqual(current, after))
             continue;
@@ -661,6 +1124,8 @@ export async function reconcileProjectProjections(options) {
             continue;
         }
         if (before === undefined || current === undefined) {
+            if (!isDeltaPath && mirrorSlots.length > 0)
+                continue;
             conflicts.push({
                 path: projectionPath,
                 driver,
@@ -673,6 +1138,8 @@ export async function reconcileProjectProjections(options) {
             continue;
         }
         if (current.kind !== "file") {
+            if (!isDeltaPath && mirrorSlots.length > 0)
+                continue;
             conflicts.push({
                 path: projectionPath,
                 driver,
@@ -702,16 +1169,19 @@ export async function reconcileProjectProjections(options) {
                 current,
                 after,
                 identitySets: combinedIdentitySets(beforePolicy, afterPolicy),
+                mirrorSlots,
             })
             : undefined;
         const text = driver === "text"
-            ? reconcileTextEntry({ before, current, after })
+            ? reconcileTextEntry({ before, current, after, mirrorSlots })
             : undefined;
+        if (structured?.ok === true && "skip" in structured)
+            continue;
         const reconciled = driver === "text"
             ? text?.ok
                 ? text.entry
                 : undefined
-            : structured?.ok
+            : structured?.ok && "entry" in structured
                 ? structured.entry
                 : undefined;
         if (reconciled === undefined) {
@@ -1031,12 +1501,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 +1540,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/release-toolchain-snapshot.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI 发版携带的不可变工具链快照：从模板根三个原生声明（engines.node、packageManager、rust-toolchain.toml）投影的静态交付副本。
+ * 模板根声明仍是唯一作者真源，由根版本门核对漂移；本模块同步、无参、无任何文件系统、网络或模板根查找。
+ */
+export declare const releaseToolchainSnapshot: Readonly<{
+    readonly nodeVersion: "24.21.0";
+    readonly packageManagerPin: "pnpm@12.9.1";
+    readonly rustVersion: "1.99.0";
+}>;
+export type ReleaseToolchainSnapshot = typeof releaseToolchainSnapshot;