@ykdz/template 0.0.36 → 0.0.38

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

@@ -183,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)
@@ -206,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)
@@ -467,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)
@@ -490,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`);
@@ -536,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) {
@@ -563,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) {
@@ -572,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 ||
@@ -583,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 ||
@@ -696,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);
@@ -713,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;
@@ -746,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,
@@ -758,6 +1138,8 @@ export async function reconcileProjectProjections(options) {
             continue;
         }
         if (current.kind !== "file") {
+            if (!isDeltaPath && mirrorSlots.length > 0)
+                continue;
             conflicts.push({
                 path: projectionPath,
                 driver,
@@ -787,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) {

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;

package/node_modules/@ykdz/template-core/dist/release-toolchain-snapshot.js

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

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

@@ -65,7 +65,8 @@ function isProtectedSourceBackedOperation(operation) {
 export function isProtectedGeneratedPath(generatedPath) {
     const normalizedPath = generatedPath.split("\\").join("/");
     const fileName = normalizedPath.split("/").at(-1);
-    return (normalizedPath === ".devcontainer/Dockerfile" ||
+    return (normalizedPath === "scripts/check-standalone-deployment.ts" ||
+        normalizedPath === "scripts/container-entrypoint.sh" ||
         normalizedPath === ".devcontainer/devcontainer.json" ||
         normalizedPath === ".github/dependabot.yml" ||
         normalizedPath.startsWith(".github/workflows/") ||
@@ -73,6 +74,8 @@ export function isProtectedGeneratedPath(generatedPath) {
         normalizedPath.startsWith("scripts/npm-publication/") ||
         normalizedPath.startsWith("scripts/npm-publication-setup/") ||
         fileName === "CHANGELOG.md" ||
+        fileName === ".dockerignore" ||
+        fileName === "Dockerfile" ||
         fileName === "LICENSE" ||
         fileName === "README.md" ||
         fileName === "RELEASING.md" ||
@@ -463,7 +466,7 @@ const rootTsconfigConfigCompilerOptions = {
     noEmitOnError: true,
     skipLibCheck: false,
     strict: true,
-    target: "es2023",
+    target: "es2024",
 };
 const rootTsconfigConfigIncludes = new Set([
     "oxlint.config.ts",
@@ -507,12 +510,13 @@ function isAllowedStructuralMachineDeclaration(sourceFile, operation) {
         operation.to === ".devcontainer/devcontainer.json") {
         return isDevelopmentContainerToolLayerMergeValue(operation.value);
     }
+    if ((operation.kind === "writeJson" || operation.kind === "mergeJson") &&
+        operation.to === "turbo.json") {
+        return isStructuralTurboValue(operation.value);
+    }
     if (operation.kind !== "writeJson") {
         return false;
     }
-    if (operation.to === "turbo.json") {
-        return isStructuralTurboValue(operation.value);
-    }
     if (operation.to === "tsconfig.config.json") {
         return isStructuralTsconfigConfigValue(operation.value);
     }
@@ -662,10 +666,12 @@ function expectedDiagnosticOwnerPaths(options) {
             return { valid: false, value: "" };
         }
         const ownerPath = declaration.owner.path;
-        if (declaration.owner.kind !== "package-boundary" ||
-            typeof ownerPath !== "string" ||
-            !isSafePackageBoundaryPath(ownerPath) ||
-            !blueprintOwners.has(ownerPath)) {
+        const workspaceOwner = declaration.owner.kind === "workspace-orchestration" && ownerPath === ".";
+        const packageOwner = declaration.owner.kind === "package-boundary" &&
+            typeof ownerPath === "string" &&
+            isSafePackageBoundaryPath(ownerPath) &&
+            blueprintOwners.has(ownerPath);
+        if (!workspaceOwner && !packageOwner) {
             return { valid: false, value: "" };
         }
         owners.add(ownerPath);

package/node_modules/@ykdz/template-core/node_modules/valibot/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Fabian Hiller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.