@ykdz/template 0.0.41 → 0.1.0-experimental.0

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

@@ -1,111 +1,87 @@
-import type { PackageContribution } from "./package-contribution.ts";
-import type { PackageDefinition, PackageRole, ProjectBlueprintDraft } from "./project-blueprint.ts";
-import type { TemplateSourceHandle } from "./renderer.ts";
-/** Stable, preset-agnostic input supplied after toolchain resolution. */
-export type GenerationContext = {
-    readonly targetDir: string;
-    readonly repositoryName: string;
-    readonly defaultPackageScope: string;
-    readonly foundationPackages: {
-        readonly typescriptConfiguration: {
-            readonly name: string;
-        };
-    };
-    readonly toolchain: {
-        readonly nodeLtsMajor: string;
-        readonly packageManagerPin: string;
-        /**
-         * 只有确实已知的精确三段 Node 版本才写入：初始化取自 CLI 发版快照，加包取自目标根现行精确声明。
-         * 纯大版本根保持缺省，不从 nodeLtsMajor 伪造 patch；该字段也不是任何版本回退的来源。
-         */
-        readonly nodeVersion?: string;
-        /**
-         * 只有确实已知的 Rust channel 才写入：初始化取自 CLI 发版快照的精确版本，已有 Rust 能力的
-         * 目标仓库在加包时取自其根 rust-toolchain.toml 的现行声明。该字段同样不是版本回退的来源，
-         * 也不进入 Environment Needs 或 Generation Record。
-         */
-        readonly rustVersion?: string;
-    };
+import type { ContentIdentity } from "./content-identity.ts";
+import type { PackageDefinition } from "./project-blueprint.ts";
+export type PresetOperation = "init" | "add";
+/** 声明预设项目行为的所属原生包出口。 */
+export type PresetOwnerDeclaration = {
+    readonly packageName: string;
+    readonly exportPath: string;
 };
-/** An in-memory plan tagged with the stable adapter that can replay it. */
-export type PlannedPackageContribution = PackageContribution & {
-    readonly planningIdentity: string;
+/** 记录中的预设选择使用完整规范身份。 */
+export type PresetOwnerSelection = ContentIdentity;
+/** 从包清单实际公开指向预设声明的出口推导其持久身份。 */
+export declare function presetOwnerFromManifest(manifest: unknown, exportPath: string): PresetOwnerDeclaration;
+/** 预设只计算项目要求；实际写入仍由工作区策略解释并投影。 */
+export type PresetProjectOptions<Context, Contribution> = {
+    readonly context: Context;
+    readonly contributions: readonly Contribution[];
+    readonly nodeInstances: ReadonlyMap<string, PackageDefinition>;
 };
-/** Narrow access to initial sibling packages, keyed by stable adapter identity. */
-export type InitialPackageDefinitionLookup = {
-    require(identity: string): PackageDefinition;
+/** 既有仓更新前的效果阶段，可读取并校验预设仍依赖的工作树事实。 */
+export type PresetUpdateOptions<Context, Contribution> = PresetProjectOptions<Context, Contribution> & {
+    readonly targetRoot: string;
 };
-export type PackageContributionReplayAdapter = {
-    readonly identity: string;
-    identify(contribution: PackageContribution): PlannedPackageContribution;
-    replay(options: {
-        readonly context: GenerationContext;
-        readonly planningContribution: "foundationPlan" | "planInitialization" | "planPackageAddition";
-        readonly packageDefinition: PackageDefinition;
-        readonly packageLeafName: string;
-        readonly initialPackages: InitialPackageDefinitionLookup;
-    }): PackageContribution;
+type PresetProjectFields<Options, ProjectContribution> = {
+    readonly owner?: PresetOwnerDeclaration;
+    readonly validateUpdate?: [Options] extends [never] ? never : (options: Options & {
+        readonly targetRoot: string;
+    }) => void | Promise<void>;
+    readonly project?: [Options] extends [never] ? never : (options: Options) => ProjectContribution;
 };
-/**
- * Declares one stable replay semantic. Persisted provenance selection and
- * diagnostics stay with the Foundation instead of leaking into Presets.
- */
-export declare function definePackageContributionReplayAdapter(options: {
-    readonly identity: string;
-    readonly replay: PackageContributionReplayAdapter["replay"];
-}): PackageContributionReplayAdapter;
-export type ResolvedPrimaryPackageIdentity = {
-    readonly leafName: string;
-    readonly definition: PackageDefinition;
+export type PresetReference = {
+    readonly alias: string;
+    readonly instance: "shared" | "independent";
 };
-/** Optional behavior owned only by Presets with a configurable initial package. */
-export type InitialPrimaryPackageCapability = {
-    readonly defaultLeafName: string;
-    readonly role: PackageRole;
-    defaultPackagePath(options: {
-        readonly packageLeafName: string;
-    }): string;
-    planInitialContribution(options: {
-        readonly context: GenerationContext;
-        readonly resolvedPackageIdentity: ResolvedPrimaryPackageIdentity;
-    }): PlannedPackageContribution;
+export type PresetNode<Reference extends PresetReference, Layout = never, CreationInput = never> = {
+    readonly reference: Reference;
+    /** 由工作区策略解释的节点布局覆盖。 */
+    readonly layout?: Layout;
+    /** 按操作应用、并可由单次调用补充的原生创建输入。 */
+    readonly creationInput?: Partial<Record<PresetOperation, CreationInput>>;
+    readonly configuration?: Partial<Record<PresetOperation, unknown>>;
 };
-type BuiltInPresetDefinitionBase = {
+type PresetNodeMap = Readonly<Record<string, {
+    readonly reference: PresetReference;
+    readonly layout?: unknown;
+    readonly creationInput?: Partial<Record<PresetOperation, unknown>>;
+    readonly configuration?: Partial<Record<PresetOperation, unknown>>;
+}>>;
+type NodeReference<Nodes extends PresetNodeMap> = Nodes[keyof Nodes]["reference"];
+type NodeLayout<Nodes extends PresetNodeMap> = Nodes[keyof Nodes] extends infer Node ? Node extends {
+    readonly layout: infer Layout;
+} ? Layout : never : never;
+type NodeCreationInput<Nodes extends PresetNodeMap> = Nodes[keyof Nodes] extends infer Node ? Node extends {
+    readonly creationInput: infer Inputs;
+} ? Inputs extends object ? Inputs[keyof Inputs] : never : never : never;
+export type PresetDefinition<Reference extends PresetReference, Layout = never, CreationInput = never, ProjectOptions = never, ProjectContribution = never> = {
+    readonly kind: "preset";
     readonly metadata: {
-        readonly name: string;
+        readonly alias: string;
         readonly title: string;
         readonly description: string;
     };
-    /** The Definition owns its Preset-local Self-Checking Template Source. */
-    readonly source: TemplateSourceHandle;
-    /** The owned planner source inspected by the Template Boundary Check. */
-    readonly plannerSourceFile: string;
-    /** Stable semantics used to replay persisted Package Definitions. */
-    readonly packageContributionReplayAdapters: readonly PackageContributionReplayAdapter[];
-    /** Package layout is Preset-owned even when callers omit --path. */
-    defaultPackagePath?(options: {
-        readonly context: GenerationContext;
-        readonly packageLeafName: string;
-    }): string;
-    planPackageAddition?(options: {
-        readonly context: GenerationContext;
-        readonly packageLeafName: string;
-        readonly packagePath: string;
-    }): PlannedPackageContribution;
+    readonly operations: readonly PresetOperation[];
+    readonly nodes: Readonly<Record<string, PresetNode<Reference, Layout, CreationInput>>>;
+} & PresetProjectFields<ProjectOptions, ProjectContribution>;
+type PresetBaseOptions<Nodes extends PresetNodeMap> = {
+    readonly metadata: PresetDefinition<NodeReference<Nodes>>["metadata"];
+    readonly operations: readonly PresetOperation[];
+    readonly nodes: Nodes;
 };
-type ConfigurablePrimaryPackagePresetDefinition = BuiltInPresetDefinitionBase & {
-    readonly initialPrimaryPackage: InitialPrimaryPackageCapability;
-    readonly blueprint?: never;
-    readonly planInitialization?: never;
-    readonly planInitializationContributions?: never;
+/** 创建不读取资源、不执行规划的预设组合声明。 */
+export declare function definePreset<const Nodes extends PresetNodeMap>(options: PresetBaseOptions<Nodes> & {
+    readonly owner?: PresetOwnerDeclaration;
+    readonly project?: never;
+    readonly validateUpdate?: never;
+}): PresetDefinition<NodeReference<Nodes>, NodeLayout<Nodes>, NodeCreationInput<Nodes>> & {
+    readonly nodes: Nodes;
 };
-type FixedTopologyPresetDefinition = BuiltInPresetDefinitionBase & {
-    readonly initialPrimaryPackage?: never;
-    blueprint(context: GenerationContext): ProjectBlueprintDraft;
-    planInitialization(context: GenerationContext): PlannedPackageContribution;
-    /** Multi-package Definitions expose their complete owned topology directly. */
-    planInitializationContributions?(context: GenerationContext): readonly PlannedPackageContribution[];
+export declare function definePreset<const Nodes extends PresetNodeMap, ProjectOptions extends PresetProjectOptions<unknown, unknown>, ProjectContribution>(options: PresetBaseOptions<Nodes> & {
+    readonly owner: PresetOwnerDeclaration;
+    readonly project: (options: ProjectOptions) => ProjectContribution;
+    readonly validateUpdate?: (options: ProjectOptions & {
+        readonly targetRoot: string;
+    }) => void | Promise<void>;
+}): PresetDefinition<NodeReference<Nodes>, NodeLayout<Nodes>, NodeCreationInput<Nodes>, ProjectOptions, ProjectContribution> & {
+    readonly nodes: Nodes;
 };
-/** A side-effect-free Built-in Preset planner. */
-export type BuiltInPresetDefinition = ConfigurablePrimaryPackagePresetDefinition | FixedTopologyPresetDefinition;
 export {};

package/node_modules/@ykdz/template-core/dist/preset-definition.js

@@ -1,16 +1,108 @@
-/**
- * Declares one stable replay semantic. Persisted provenance selection and
- * diagnostics stay with the Foundation instead of leaking into Presets.
- */
-export function definePackageContributionReplayAdapter(options) {
-    if (options.identity.length === 0) {
-        throw new Error("Package Contribution replay adapter identity is required");
-    }
-    return {
-        identity: options.identity,
-        identify(contribution) {
-            return { ...contribution, planningIdentity: options.identity };
-        },
-        replay: options.replay,
-    };
+/** 从包清单实际公开指向预设声明的出口推导其持久身份。 */
+export function presetOwnerFromManifest(manifest, exportPath) {
+    if (!isRecord(manifest) || typeof manifest.name !== "string") {
+        throw new Error("预设所属包清单缺少包名");
+    }
+    requireText(manifest.name, "所属包名");
+    if (!isRecord(manifest.exports)) {
+        throw new Error("预设所属包清单缺少公开出口");
+    }
+    if ((exportPath !== "." && !exportPath.startsWith("./")) ||
+        !Object.hasOwn(manifest.exports, exportPath)) {
+        throw new Error("预设所属包清单未公开所选预设入口");
+    }
+    return { packageName: manifest.name, exportPath };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`预设${label}不能为空`);
+    }
+}
+export function definePreset(options) {
+    requireText(options.metadata.alias, "别名");
+    requireText(options.metadata.title, "标题");
+    requireText(options.metadata.description, "说明");
+    if (options.project !== undefined) {
+        if (!isRecord(options.owner)) {
+            throw new Error("项目预设必须声明所属包的公开导出身份");
+        }
+        requireText(options.owner.packageName, "所属包名");
+        requireText(options.owner.exportPath, "公开导出路径");
+        if (options.owner.exportPath !== "." &&
+            !options.owner.exportPath.startsWith("./")) {
+            throw new Error("预设公开导出路径必须是包的公开入口");
+        }
+    }
+    if (!Array.isArray(options.operations) || options.operations.length === 0) {
+        throw new Error("预设至少允许一种操作");
+    }
+    const operations = [];
+    for (const operation of options.operations) {
+        if (operation !== "init" && operation !== "add") {
+            throw new Error(`预设操作无效：${String(operation)}`);
+        }
+        if (operations.includes(operation)) {
+            throw new Error(`预设操作重复：${operation}`);
+        }
+        operations.push(operation);
+    }
+    const nodeEntries = Object.entries(options.nodes);
+    if (nodeEntries.length === 0) {
+        throw new Error("预设至少声明一个节点");
+    }
+    const independentReferences = new Set();
+    const nodes = {};
+    for (const [identity, value] of nodeEntries) {
+        if (!/^[a-z][a-z0-9-]*$/u.test(identity)) {
+            throw new Error(`预设节点身份无效：${identity}`);
+        }
+        if (!isRecord(value) ||
+            !isRecord(value.reference) ||
+            typeof value.reference.alias !== "string" ||
+            value.reference.alias.trim().length === 0 ||
+            !["shared", "independent"].includes(String(value.reference.instance))) {
+            throw new Error(`预设节点缺少有效参考：${identity}`);
+        }
+        const reference = value.reference;
+        if (reference.instance === "independent") {
+            if (independentReferences.has(reference)) {
+                throw new Error(`预设重复选择独立参考：${reference.alias}`);
+            }
+            independentReferences.add(reference);
+        }
+        if (value.creationInput !== undefined) {
+            if (!isRecord(value.creationInput)) {
+                throw new Error(`预设节点创建输入无效：${identity}`);
+            }
+            for (const operation of Object.keys(value.creationInput)) {
+                if ((operation !== "init" && operation !== "add") ||
+                    !options.operations.includes(operation)) {
+                    throw new Error(`预设节点创建输入操作无效：${identity}/${operation}`);
+                }
+                if (!isRecord(value.creationInput[operation])) {
+                    throw new Error(`预设节点创建输入必须是对象：${identity}/${operation}`);
+                }
+            }
+        }
+        nodes[identity] = Object.freeze({
+            ...value,
+            reference,
+        });
+    }
+    return Object.freeze({
+        kind: "preset",
+        metadata: Object.freeze({ ...options.metadata }),
+        operations: Object.freeze(operations),
+        nodes: Object.freeze(nodes),
+        ...(options.owner === undefined
+            ? {}
+            : { owner: Object.freeze({ ...options.owner }) }),
+        ...(options.project === undefined ? {} : { project: options.project }),
+        ...(options.validateUpdate === undefined
+            ? {}
+            : { validateUpdate: options.validateUpdate }),
+    });
 }

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

@@ -3,8 +3,8 @@ import * as v from "valibot";
  * The durable, preset-agnostic topology used by local template follow-up
  * operations. Preset provenance deliberately belongs in Generation Record.
  */
-declare const packageRoles: readonly ["cli-tool", "runtime-service", "shared-library", "native-package"];
-export type PackageRole = (typeof packageRoles)[number];
+/** 角色含义由所选工作区策略解释。 */
+export type PackageRole = string;
 export type PackageDefinition = {
     readonly name: string;
     readonly path: string;
@@ -47,7 +47,7 @@ export declare const projectBlueprintSchema: v.StrictObjectSchema<{
     readonly packages: v.ArraySchema<v.StrictObjectSchema<{
         readonly name: v.StringSchema<"Package name must be a string">;
         readonly path: v.StringSchema<"Package Path must be a string">;
-        readonly role: v.PicklistSchema<readonly ["cli-tool", "runtime-service", "shared-library", "native-package"], "Package Role must be cli-tool, runtime-service, shared-library, or native-package">;
+        readonly role: v.StringSchema<"Package Role must be a string">;
         readonly packageDefinitionId: v.StringSchema<"Package Definition ID must use the package-<sha256> format">;
     }, typeof packageDefinitionMessage>, "Package Definitions must be an array">;
     readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
@@ -55,14 +55,6 @@ export declare const projectBlueprintSchema: v.StrictObjectSchema<{
         readonly providerPackagePath: v.StringSchema<"Package Link Intent provider Package Path must be a string">;
     }, (issue: v.StrictObjectIssue) => "Package Link Intent must be an object" | "Unknown Blueprint v3 field">, "Package Link Intents must be an array">, undefined>;
 }, (issue: v.StrictObjectIssue) => "Local Template Metadata must be an object" | "Unknown Blueprint v3 field">;
-/** Canonical npm package-name predicate shared by Blueprint and input preparation. */
-export declare function isValidNewNpmPackageName(value: string): boolean;
-export type NewPackagePathValidation = {
-    readonly hasValidShape: boolean;
-    readonly reservedWorkspaceCollection?: string;
-};
-/** Canonical Package Path facts shared by Blueprint and input preparation. */
-export declare function validateNewPackagePath(value: string): NewPackagePathValidation;
 /** Validates persisted metadata before it is used to plan or render changes. */
 export declare function validateProjectBlueprint(value: unknown): BlueprintValidationResult;
 /** Validates preset-owned topology before any persisted identity is assigned. */

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

@@ -1,31 +1,10 @@
-import { isBuiltin } from "node:module";
+import path from "node:path";
 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"),
+    role: v.string("Package Role must be a string"),
 };
 function packageDefinitionMessage(issue) {
     return issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
@@ -49,43 +28,18 @@ export const projectBlueprintSchema = v.strictObject({
 }, (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 isNormalizedSafeRelativePath(value) {
+    const normalized = path.posix.normalize(value);
+    return (value.length > 0 &&
+        !value.includes("\0") &&
+        !value.includes("\\") &&
+        !path.posix.isAbsolute(value) &&
+        path.win32.parse(value).root.length === 0 &&
+        !value.endsWith("/") &&
+        normalized !== "." &&
+        normalized !== ".." &&
+        !normalized.startsWith("../") &&
+        normalized === value);
 }
 function blueprintIssuePath(issue) {
     let result = ".";
@@ -118,9 +72,8 @@ function blueprintStructureMessage(issue) {
     }
     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.endsWith(".role"))
+        return "Package Role must be a string";
     if (path === ".packageLinkIntents") {
         return "Package Link Intents must be an array";
     }
@@ -136,23 +89,22 @@ 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)) {
+        if (definition.name.length === 0) {
             issues.push({
                 path: `${itemPath}.name`,
-                message: "Package name must be a valid npm package name for new packages",
+                message: "Package name must not be empty",
             });
         }
-        if (pathValidation.reservedWorkspaceCollection !== undefined) {
+        if (definition.role.length === 0) {
             issues.push({
-                path: `${itemPath}.path`,
-                message: `Package Path ${definition.path} uses reserved workspace collection ${pathValidation.reservedWorkspaceCollection}`,
+                path: `${itemPath}.role`,
+                message: "Package Role must not be empty",
             });
         }
-        else if (!pathValidation.hasValidShape) {
+        if (!isNormalizedSafeRelativePath(definition.path)) {
             issues.push({
                 path: `${itemPath}.path`,
-                message: "Package Path must be exactly two safe path segments",
+                message: "Package Path must be a normalized safe relative path",
             });
         }
     }

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

@@ -12,9 +12,7 @@ class ProjectProjectionPathPreconditionError extends Error {
     }
 }
 function normalizedOutputPath(operation) {
-    const operationPath = operation.kind === "setExecutable" || operation.kind === "replaceAnchors"
-        ? operation.path
-        : operation.to;
+    const operationPath = operation.kind === "setExecutable" ? operation.path : operation.to;
     if (path.isAbsolute(operationPath)) {
         throw new Error(`Project Projection paths must be relative: ${operationPath}`);
     }
@@ -37,8 +35,6 @@ function operationDriver(operation) {
         case "writeTextFromFragments":
         case "writeTextTemplate":
             return "text";
-        case "replaceAnchors":
-            return "text";
         case "setExecutable":
             return undefined;
     }
@@ -61,20 +57,11 @@ export function validateProjectProjectionPlan(options) {
         }
         finalPaths.add(outputPath);
         const precedingKind = contentKindByPath.get(outputPath);
-        if (operation.kind === "setExecutable" ||
-            operation.kind === "replaceAnchors") {
+        if (operation.kind === "setExecutable") {
             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");
-                }
+            if (precedingKind !== undefined) {
                 transformationKindByPath.set(outputPath, operation.kind);
             }
             continue;
@@ -1516,7 +1503,7 @@ export async function materializeProjectProjection(options) {
                 throw new Error(`Project Projection setExecutable requires a preceding content-producing operation: ${outputPath}`);
             }
         }
-        else if (operation.kind !== "replaceAnchors") {
+        else {
             contentPaths.add(outputPath);
         }
         const driver = operationDriver(operation);

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

@@ -0,0 +1 @@
+export declare const generatedJsonPrintWidth = 80;

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

@@ -0,0 +1,2 @@
+// 由根 sync:workspace-policy 从格式化器原生配置派生，请修改事实源后显式同步。
+export const generatedJsonPrintWidth = 80;

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

@@ -47,6 +47,7 @@ export type MergeJsonTemplateOperation = {
     from: string;
     to: string;
     source: TemplateSourceHandle;
+    replacements?: Record<string, string>;
     multilineArrays?: string[];
     keyOrder?: readonly string[];
     nestedKeyOrder?: readonly string[];
@@ -56,6 +57,12 @@ export type WriteTextOperation = {
     kind: "writeText";
     to: string;
     text: string;
+    mode?: number;
+    overwrite?: boolean;
+    templateSource?: {
+        readonly handle: TemplateSourceHandle;
+        readonly path: string;
+    };
     provenance?: RenderOperationProvenance;
 };
 export type WriteTextFromFragmentsOperation = {
@@ -65,7 +72,6 @@ export type WriteTextFromFragmentsOperation = {
         from: string;
         source: TemplateSourceHandle;
     }[];
-    validation?: "development-container-dockerfile" | undefined;
     overwrite?: boolean;
     provenance?: RenderOperationProvenance;
 };
@@ -85,34 +91,11 @@ export type SetExecutableOperation = {
     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 | MergeJsonTemplateOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation | ReplaceAnchorsOperation;
+export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | MergeJsonTemplateOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation;
 export type RenderProjectOptions = {
     targetRoot: string;
     operations: RenderOperation[];
 };
 export declare function renderProject(options: RenderProjectOptions): Promise<void>;
-export type AtomicPathCommitOptions = {
-    readonly relativePath: string;
-    readonly stagingRoot: string;
-    readonly targetRoot: string;
-    readonly commit: () => Promise<void>;
-};
-export type AtomicProjectRendererDependencies = {
-    readonly commitPath?: (options: AtomicPathCommitOptions) => Promise<void>;
-};
-/**
- * Creates a renderer that applies a follow-up plan in a sibling staging
- * directory. Metadata updates cannot become visible when a later source
- * operation fails.
- */
-export declare function createAtomicProjectRenderer(dependencies?: AtomicProjectRendererDependencies): (options: RenderProjectOptions) => Promise<void>;
-export declare const renderProjectAtomically: (options: RenderProjectOptions) => Promise<void>;
 export declare function renderNewProject(options: RenderProjectOptions): Promise<void>;
 export {};