@ykdz/template 0.0.42 → 0.1.0-experimental.1

package/dist/application.d.ts

@@ -1,5 +1,8 @@
-import { type GeneratedRepositoryPlan, type InitializationInputIssue, type PackageAdditionInputIssue, type NextStepInstruction, type ProjectBlueprint, type PublicationSetupHandoff, type ResolvedInitialization } from "@ykdz/template-builtin-presets";
+import { type ProjectBlueprint } from "@ykdz/template-core/project-blueprint";
 import { type ProjectProjectionAction, type ProjectProjectionConflict } from "@ykdz/template-core/project-projection";
+import type { GenerationRecord } from "@ykdz/template-generator";
+import type { DefaultWorkspaceOwnerFacts } from "@ykdz/template-workspace/default-workspace-strategy";
+import { type InitializationInputIssue, type PackageAdditionInputIssue } from "./input-validation.ts";
 export type ApplicationRuntime = {
     readonly cwd: string;
     readonly env: Readonly<Record<string, string | undefined>>;
@@ -9,27 +12,56 @@ export type InitCommandOptions = {
     readonly preset: string;
     readonly dryRun: boolean;
     readonly todo: boolean;
+    readonly publication?: boolean;
     readonly name?: string;
     readonly path?: string;
     readonly scope?: string;
 };
 export type AddPackageCommandOptions = {
+    readonly publication?: boolean;
     readonly preset: string;
     readonly name: string;
     readonly path?: string;
     readonly linkFrom: readonly string[];
     readonly dryRun: boolean;
 };
+export type ConfigurePackageCommandOptions = {
+    readonly path: string;
+    readonly dryRun: boolean;
+};
+export type PackageConfigurationCommandResult = Exclude<PackageAdditionCommandResult, {
+    readonly status: "usage-error";
+} | {
+    readonly status: "success";
+}> | {
+    readonly status: "success";
+    readonly packageDefinitionId: string;
+    readonly dryRun: boolean;
+    readonly actions: readonly ProjectProjectionAction[];
+} | {
+    readonly status: "usage-error";
+    readonly issues: readonly {
+        readonly code: "UNKNOWN_GENERATED_INSTANCE";
+    }[];
+};
+type ResolvedInitialization = {
+    readonly preset: string;
+    readonly topology: "configurable-primary-package" | "fixed";
+    readonly packages: readonly {
+        readonly name: string;
+        readonly path: string;
+    }[];
+    readonly scope: string;
+};
 export type InitCommandResult = {
     readonly status: "success";
     readonly dryRun: boolean;
     readonly targetDir: string;
     readonly resolved: ResolvedInitialization;
     readonly blueprint: ProjectBlueprint;
-    readonly generationRecord: GeneratedRepositoryPlan["generationRecord"];
+    readonly generationRecord: GenerationRecord;
     readonly toolchain: ReturnType<typeof toolchainReport>;
-    readonly nextSteps: readonly NextStepInstruction[];
-    readonly publicationSetup: PublicationSetupHandoff;
+    readonly nextSteps: DefaultWorkspaceOwnerFacts["nextSteps"];
     readonly followUpDocument: {
         readonly enabled: boolean;
         readonly path?: string;
@@ -130,4 +162,6 @@ declare function toolchainReport(): {
 export declare function validateBlueprintFile(filePath: string, runtime: ApplicationRuntime): Promise<BlueprintValidationCommandResult>;
 export declare function runInit(options: InitCommandOptions, runtime: ApplicationRuntime): Promise<InitCommandResult>;
 export declare function runAddPackage(options: AddPackageCommandOptions, runtime: ApplicationRuntime): Promise<PackageAdditionCommandResult>;
+/** 只按正式蓝图选择已有实例；不从原生目录推断内容来源。 */
+export declare function runConfigurePackage(options: ConfigurePackageCommandOptions, runtime: ApplicationRuntime): Promise<PackageConfigurationCommandResult>;
 export {};

package/dist/application.js

@@ -1,15 +1,16 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { builtInPresetRegistry, prepareGeneratedRepositoryPackageAddition, validateGeneratedRepositoryInitializationInput, prepareGeneratedRepositoryInitialization, templateSources, } from "@ykdz/template-builtin-presets";
-import { validateProjectBlueprint } from "@ykdz/template-core/project-blueprint";
-import { reconcileAndApplyProjectProjections, materializeProjectProjection, } from "@ykdz/template-core/project-projection";
-import { releaseToolchainSnapshot } from "@ykdz/template-core/release-toolchain-snapshot";
-import { renderNewProject } from "@ykdz/template-core/renderer";
+import { validateProjectBlueprint, assertProjectBlueprint, } from "@ykdz/template-core/project-blueprint";
+import {} from "@ykdz/template-core/project-projection";
+import { isDefaultWorkspaceMissingLinkConflict } from "@ykdz/template-workspace/default-workspace-strategy";
+import { releaseToolchainSnapshot } from "@ykdz/template-workspace/release-toolchain-snapshot";
+import { validateInitializationInput, validatePackageAdditionInput, } from "./input-validation.js";
+import { cliGenerator, cliPresets, cliWorkspaceStrategy, presetByAlias, } from "./preset-catalog.js";
 export function listPresetCatalog() {
     return {
         status: "success",
-        presets: builtInPresetRegistry.all().map((definition) => ({
-            name: definition.metadata.name,
+        presets: cliPresets.map(({ definition }) => ({
+            name: definition.metadata.alias,
             title: definition.metadata.title,
             description: definition.metadata.description,
         })),
@@ -99,197 +100,257 @@ function readBlueprintFailure(filePath, error) {
     };
 }
 function initOperationFailure(options) {
-    const phase = options.phase === "preset"
-        ? "预设准备"
-        : options.phase === "planning"
-            ? "生成规划"
-            : options.phase === "preflight"
-                ? "生成预检"
-                : options.phase === "materialization"
-                    ? "生成物料化"
-                    : "目标目录渲染";
+    const phase = options.phase === "render" ? "render" : "planning";
+    const phaseName = phase === "planning" ? "生成规划" : "目标目录渲染";
+    const fallbackMessage = `${phaseName}失败。`;
     return {
         status: "operation-failure",
-        phase: options.phase,
+        phase,
         targetDir: options.targetDir,
         error: {
-            message: `${phase}失败。`,
-            suggestion: "检查目标目录与运行环境后重试；若问题持续发生，请人工处理。",
+            message: options.message === undefined
+                ? fallbackMessage
+                : safeGeneratorFailureMessage(options.message, fallbackMessage),
+            suggestion: options.message === undefined
+                ? "检查目标目录与运行环境后重试；若问题持续发生，请人工处理。"
+                : "根据错误信息检查所属内容包及其声明资源、目标目录后重试；若问题持续发生，请人工处理。",
         },
     };
 }
+function safeGeneratorFailureMessage(message, fallback) {
+    const firstLine = message.split(/\r?\n/u, 1)[0]?.trim();
+    if (firstLine === undefined || firstLine.length === 0)
+        return fallback;
+    return firstLine
+        .replace(/file:\/\/\S+/gu, "本地模块路径")
+        .replace(/(^|[\s("'`])(?:[A-Za-z]:[\\/]|\/)[^\s"'`)]*/gu, "$1本地路径");
+}
+function initPackageIdentities(presetAlias, generationRecord, blueprint) {
+    const preset = presetByAlias(presetAlias);
+    if (preset === undefined)
+        throw new Error("初始化预设在结果映射时不存在");
+    return Object.keys(preset.definition.nodes).map((nodeIdentity) => {
+        const packageDefinitionId = generationRecord.nodeInstances[nodeIdentity];
+        const record = generationRecord.packages.find((candidate) => candidate.packageDefinitionId === packageDefinitionId);
+        if (record === undefined) {
+            throw new Error("生成结果缺少预设节点对应的包实例：" + nodeIdentity);
+        }
+        const definition = blueprint.packages.find((candidate) => candidate.packageDefinitionId === record.packageDefinitionId);
+        if (definition === undefined) {
+            throw new Error("生成结果蓝图缺少预设节点对应的包定义：" + nodeIdentity);
+        }
+        return {
+            name: definition.name,
+            path: definition.path,
+        };
+    });
+}
 export async function runInit(options, runtime) {
     const targetDir = path.resolve(runtime.cwd, options.dir);
-    const overrides = (options.name ?? options.path ?? options.scope) === undefined
-        ? undefined
-        : {
+    const validation = validateInitializationInput({
+        preset: options.preset,
+        targetDir,
+        overrides: {
             ...(options.name === undefined ? {} : { name: options.name }),
             ...(options.path === undefined ? {} : { path: options.path }),
             ...(options.scope === undefined ? {} : { scope: options.scope }),
-        };
-    const input = validateGeneratedRepositoryInitializationInput({
-        preset: options.preset,
-        targetDir,
-        ...(overrides === undefined ? {} : { overrides }),
+        },
     });
-    if (input.status === "input-invalid") {
+    if (validation.status === "input-invalid") {
         return {
             status: "usage-error",
             targetDir: options.dir,
-            issues: input.issues,
+            issues: validation.issues,
         };
     }
-    const preparation = prepareGeneratedRepositoryInitialization({
-        preset: options.preset,
-        targetDir,
-        ...(overrides === undefined ? {} : { overrides }),
+    const { preset, repositoryName, defaultPackageScope } = validation.value;
+    const creationInput = options.name === undefined && options.path === undefined
+        ? undefined
+        : {
+            ...(options.name === undefined ? {} : { leafName: options.name }),
+            ...(options.path === undefined ? {} : { packagePath: options.path }),
+        };
+    const result = await cliGenerator.init({
+        targetRoot: targetDir,
+        selection: {
+            roots: [
+                {
+                    preset: preset.identity,
+                    ...(options.publication
+                        ? { configuration: { publication: true } }
+                        : {}),
+                    ...(creationInput === undefined ? {} : { creationInput }),
+                },
+            ],
+        },
+        strategyInput: { repositoryName, defaultPackageScope, todo: options.todo },
+        dryRun: options.dryRun,
     });
-    if (preparation.status === "input-invalid") {
+    if (result.status === "operation-failure") {
+        return initOperationFailure({
+            phase: result.phase,
+            targetDir: options.dir,
+            message: result.error.message,
+        });
+    }
+    if (result.status === "input-invalid") {
         return {
             status: "usage-error",
             targetDir: options.dir,
-            issues: preparation.issues,
+            issues: result.issues.map(({ code }) => ({
+                code: code,
+            })),
         };
     }
-    if (preparation.status === "operation-failure") {
-        return initOperationFailure({
-            phase: preparation.phase,
-            targetDir: options.dir,
-        });
-    }
-    const { plan, resolved, publicationSetup } = preparation;
-    const operations = [
-        ...plan.operations,
-        ...(options.todo
-            ? [
-                {
-                    kind: "writeTextTemplate",
-                    source: templateSources.foundation,
-                    from: "TODO.md.template",
-                    to: "TODO.md",
-                    replacements: {
-                        NEXT_STEPS: plan.nextStepInstructions
-                            .map((instruction, index) => `${index + 1}. \`${instruction.display}\``)
-                            .join("\n"),
-                    },
-                },
-            ]
-            : []),
-    ];
-    try {
-        await materializeProjectProjection({
-            operations,
-            reconciliation: plan.reconciliation,
-        });
+    if (result.status === "conflict") {
+        return initOperationFailure({ phase: "render", targetDir: options.dir });
     }
-    catch {
-        return initOperationFailure({
-            phase: "materialization",
-            targetDir: options.dir,
-        });
+    const strategyState = cliWorkspaceStrategy.parseState(result.generationRecord.strategyState);
+    const ownerFacts = result.projection?.ownerFacts;
+    if (ownerFacts === undefined) {
+        throw new Error("默认工作区策略未返回初始化事实");
     }
-    const output = {
+    return {
         status: "success",
         dryRun: options.dryRun,
         targetDir: options.dir,
-        resolved,
-        blueprint: plan.blueprint,
-        generationRecord: plan.generationRecord,
+        resolved: {
+            preset: preset.definition.metadata.alias,
+            topology: Object.keys(preset.definition.nodes).length === 1
+                ? "configurable-primary-package"
+                : "fixed",
+            packages: initPackageIdentities(preset.definition.metadata.alias, result.generationRecord, result.blueprint),
+            scope: strategyState.defaultPackageScope,
+        },
+        blueprint: result.blueprint,
+        generationRecord: result.generationRecord,
         toolchain: toolchainReport(),
-        nextSteps: plan.nextStepInstructions,
-        publicationSetup,
+        nextSteps: ownerFacts.nextSteps,
         followUpDocument: {
-            enabled: options.todo,
-            ...(options.todo ? { path: "TODO.md" } : {}),
+            enabled: strategyState.todo,
+            ...(strategyState.todo ? { path: "TODO.md" } : {}),
+        },
+    };
+}
+function packageUpdateOperationFailure(phase, diagnostic, message, fallbackMessage = "添加 Package 时发生操作失败。") {
+    const mappedPhase = phase === "render" ? "reconciliation" : phase;
+    return {
+        status: "operation-failure",
+        phase: mappedPhase,
+        error: diagnostic ?? {
+            message: message === undefined
+                ? fallbackMessage
+                : safeGeneratorFailureMessage(message, fallbackMessage),
+            suggestion: message === undefined
+                ? "检查生成仓库元数据与工作区状态后重试；若问题持续发生，请人工处理。"
+                : "根据错误信息检查生成记录、包绑定或所属内容资源后重试；若问题持续发生，请人工处理。",
         },
     };
-    if (options.dryRun)
-        return output;
-    try {
-        await renderNewProject({
-            targetRoot: path.resolve(runtime.cwd, options.dir),
-            operations,
-        });
-    }
-    catch {
-        return initOperationFailure({ phase: "render", targetDir: options.dir });
-    }
-    return output;
 }
 export async function runAddPackage(options, runtime) {
-    const preparation = prepareGeneratedRepositoryPackageAddition({
-        repositoryRoot: runtime.cwd,
+    const validation = validatePackageAdditionInput({
         preset: options.preset,
         packageLeafName: options.name,
+        linkFrom: options.linkFrom,
         ...(options.path === undefined ? {} : { packagePath: options.path }),
-        ...(options.linkFrom.length === 0 ? {} : { linkFrom: options.linkFrom }),
     });
-    if (preparation.status === "input-invalid") {
+    if (validation.status === "input-invalid") {
+        return { status: "usage-error", issues: validation.issues };
+    }
+    const result = await cliGenerator.add({
+        repositoryRoot: runtime.cwd,
+        preset: validation.preset.identity,
+        ...(options.publication ? { configuration: { publication: true } } : {}),
+        creationInput: {
+            leafName: options.name,
+            ...(options.path === undefined ? {} : { packagePath: options.path }),
+            ...(validation.linkFrom.length === 0
+                ? {}
+                : { linkFrom: validation.linkFrom }),
+        },
+        dryRun: options.dryRun,
+    });
+    if (result.status === "operation-failure") {
+        return packageUpdateOperationFailure(result.phase, result.error.diagnostic, result.error.message);
+    }
+    if (result.status === "input-invalid") {
         return {
             status: "usage-error",
-            issues: preparation.issues,
+            issues: result.issues.map(({ code }) => ({
+                code: code,
+            })),
         };
     }
-    if (preparation.status === "operation-failure") {
-        return packageAdditionOperationFailure(preparation.phase, preparation.diagnostic);
-    }
-    if (preparation.status === "conflict") {
+    if (result.status === "conflict") {
+        const missingLinkConflict = isDefaultWorkspaceMissingLinkConflict(result.ownerConflict)
+            ? {
+                kind: "missing-link",
+                ...result.ownerConflict.facts,
+            }
+            : undefined;
+        if (result.ownerConflict !== undefined &&
+            missingLinkConflict === undefined) {
+            return packageUpdateOperationFailure("planning");
+        }
         return {
             status: "conflict",
             dryRun: options.dryRun,
             actions: [],
             conflicts: [
-                {
-                    kind: preparation.conflict.kind,
-                    existing: {
-                        name: preparation.conflict.existing.name,
-                        path: preparation.conflict.existing.path,
-                        role: preparation.conflict.existing.role,
-                    },
-                    requested: {
-                        name: preparation.conflict.requested.name,
-                        path: preparation.conflict.requested.path,
-                        role: preparation.conflict.requested.role,
-                    },
-                    ...(preparation.conflict.missingLink === undefined
-                        ? {}
-                        : { missingLink: preparation.conflict.missingLink }),
-                },
+                ...(result.identityConflict === undefined
+                    ? []
+                    : [{ kind: "identity", ...result.identityConflict }]),
+                ...(missingLinkConflict === undefined ? [] : [missingLinkConflict]),
+                ...result.conflicts.map(packageAdditionConflict),
             ],
         };
     }
-    let reconciliation;
+    return {
+        status: "success",
+        dryRun: options.dryRun,
+        actions: result.actions,
+    };
+}
+/** 只按正式蓝图选择已有实例；不从原生目录推断内容来源。 */
+export async function runConfigurePackage(options, runtime) {
+    let packageDefinitionId;
     try {
-        reconciliation = await reconcileAndApplyProjectProjections({
-            targetRoot: runtime.cwd,
-            ...preparation.plan.projectProjections,
-            dryRun: options.dryRun,
-        });
+        const blueprint = assertProjectBlueprint(JSON.parse(await readFile(path.join(runtime.cwd, ".template/blueprint.json"), "utf8")));
+        const definition = blueprint.packages.find((item) => item.path === options.path);
+        if (definition === undefined)
+            return {
+                status: "usage-error",
+                issues: [{ code: "UNKNOWN_GENERATED_INSTANCE" }],
+            };
+        packageDefinitionId = definition.packageDefinitionId;
     }
-    catch {
-        return packageAdditionOperationFailure("reconciliation");
+    catch (error) {
+        return packageUpdateOperationFailure("metadata", undefined, error instanceof Error ? error.message : String(error), "读取已有包配置时发生操作失败。");
     }
-    if (!reconciliation.ok) {
+    const result = await cliGenerator.configure({
+        repositoryRoot: runtime.cwd,
+        packageDefinitionId,
+        configuration: { publication: true },
+        dryRun: options.dryRun,
+    });
+    if (result.status === "operation-failure")
+        return packageUpdateOperationFailure(result.phase, result.error.diagnostic, result.error.message, "配置已有包时发生操作失败。");
+    if (result.status === "input-invalid")
+        return {
+            status: "usage-error",
+            issues: [{ code: "UNKNOWN_GENERATED_INSTANCE" }],
+        };
+    if (result.status === "conflict")
         return {
             status: "conflict",
             dryRun: options.dryRun,
             actions: [],
-            conflicts: reconciliation.conflicts.map(packageAdditionConflict),
+            conflicts: result.conflicts.map(packageAdditionConflict),
         };
-    }
     return {
         status: "success",
-        dryRun: options.dryRun,
-        actions: reconciliation.actions,
-    };
-}
-function packageAdditionOperationFailure(phase, diagnostic) {
-    return {
-        status: "operation-failure",
-        phase,
-        error: diagnostic ?? {
-            message: "添加 Package 时发生操作失败。",
-            suggestion: "检查生成仓库元数据与工作区状态后重试；若问题持续发生，请人工处理。",
-        },
+        packageDefinitionId,
+        dryRun: result.dryRun,
+        actions: result.actions,
     };
 }

package/dist/cli.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { nodeCliOutput } from "@ykdz/cli-contract/node";
-if (import.meta.url.endsWith(".ts")) {
-    process.env.TEMPLATE_REPOSITORY_ROOT ??= path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
-}
 const require = createRequire(import.meta.url);
 const runtime = {
     argv: process.argv,

package/dist/input-schemas.d.ts

@@ -6,6 +6,7 @@ export declare function initializationInputSchema(cwd: string): import("@valibot
     scope?: string | undefined;
     dryRun?: boolean | undefined;
     todo?: boolean | undefined;
+    publication?: boolean | undefined;
 }, {
     dir: string;
     preset: string;
@@ -14,17 +15,30 @@ export declare function initializationInputSchema(cwd: string): import("@valibot
     scope?: string | undefined;
     dryRun: boolean;
     todo: boolean;
+    publication: boolean;
 }>;
 export declare const packageAdditionInputSchema: import("@valibot/to-json-schema").StandardJsonSchema<{
     preset: string;
     name: string;
     path?: string | undefined;
     linkFrom?: string[] | undefined;
+    publication?: boolean | undefined;
     dryRun?: boolean | undefined;
 }, {
     preset: string;
     name: string;
     path?: string | undefined;
     linkFrom: string[];
+    publication: boolean;
+    dryRun: boolean;
+}>;
+/** 本轮配置入口只显式开启发布，不扩展卸载或其他配置操作。 */
+export declare const packageConfigurationInputSchema: import("@valibot/to-json-schema").StandardJsonSchema<{
+    path: string;
+    publication?: boolean | undefined;
+    dryRun?: boolean | undefined;
+}, {
+    path: string;
+    publication: boolean;
     dryRun: boolean;
 }>;

package/dist/input-schemas.js

@@ -1,8 +1,14 @@
 import path from "node:path";
-import { validateGeneratedRepositoryInitializationInput, validateGeneratedRepositoryPackageAdditionInput, } from "@ykdz/template-builtin-presets";
 import * as v from "valibot";
-import { listPresetCatalog } from "./application.js";
+import { validateInitializationInput, validatePackageAdditionInput, } from "./input-validation.js";
+import { cliPresets } from "./preset-catalog.js";
 import { standardSchema } from "./standard-schema.js";
+const initializationPresetChoices = cliPresets
+    .filter((preset) => preset.definition.operations.includes("init"))
+    .map((preset) => preset.alias);
+const additionPresetChoices = cliPresets
+    .filter((preset) => preset.definition.operations.includes("add"))
+    .map((preset) => preset.alias);
 const initializationMessages = {
     PRESET_UNKNOWN: "请选择有效的预设。",
     FIXED_TOPOLOGY_OVERRIDE: "固定拓扑预设不支持覆盖初始包名称或路径。",
@@ -16,17 +22,18 @@ const initializationMessages = {
 export function initializationInputSchema(cwd) {
     return standardSchema(v.pipe(v.object({
         dir: v.pipe(v.string(), v.nonEmpty()),
-        preset: v.picklist(listPresetCatalog().presets.map(({ name }) => name)),
+        preset: v.picklist(initializationPresetChoices),
         name: v.optional(v.pipe(v.string(), v.description("无 scope 的 npm 包叶名称；仅可配置主包的预设允许覆盖。"))),
         path: v.optional(v.pipe(v.string(), v.description("两个安全路径段；不能使用保留目录；仅可配置主包的预设允许覆盖。"))),
         scope: v.optional(v.pipe(v.string(), v.description("有效 npm scope；省略时使用目标目录名。"))),
         dryRun: v.optional(v.boolean(), false),
         todo: v.optional(v.boolean(), true),
+        publication: v.optional(v.boolean(), false),
     }), v.rawCheck(({ dataset, addIssue }) => {
         if (!dataset.typed)
             return;
         const { dir, preset, name, path: packagePath, scope } = dataset.value;
-        const result = validateGeneratedRepositoryInitializationInput({
+        const result = validateInitializationInput({
             preset,
             targetDir: path.resolve(cwd, dir),
             overrides: {
@@ -36,8 +43,9 @@ export function initializationInputSchema(cwd) {
             },
         });
         if (result.status === "input-invalid") {
-            for (const issue of result.issues)
+            for (const issue of result.issues) {
                 addIssue({ message: initializationMessages[issue.code] });
+            }
         }
     })), ["raw_check"]);
 }
@@ -53,23 +61,34 @@ const additionMessages = {
     UNSUPPORTED_LINK: "指定的包角色不支持此链接。",
 };
 export const packageAdditionInputSchema = standardSchema(v.pipe(v.object({
-    preset: v.picklist(listPresetCatalog().presets.map(({ name }) => name)),
+    preset: v.picklist(additionPresetChoices),
     name: v.pipe(v.string(), v.description("无 scope 的 npm 包叶名称。")),
     path: v.optional(v.pipe(v.string(), v.description("两个安全路径段，不能使用保留工作区目录。"))),
     linkFrom: v.optional(v.array(v.pipe(v.string(), v.description("消费包路径：两个安全路径段，不能使用保留工作区目录。"))), []),
+    publication: v.optional(v.boolean(), false),
     dryRun: v.optional(v.boolean(), false),
 }), v.rawCheck(({ dataset, addIssue }) => {
     if (!dataset.typed)
         return;
     const input = dataset.value;
-    const result = validateGeneratedRepositoryPackageAdditionInput({
+    const result = validatePackageAdditionInput({
         preset: input.preset,
         packageLeafName: input.name,
         linkFrom: input.linkFrom,
         ...(input.path === undefined ? {} : { packagePath: input.path }),
     });
     if (result.status === "input-invalid") {
-        for (const issue of result.issues)
+        for (const issue of result.issues) {
             addIssue({ message: additionMessages[issue.code] });
+        }
     }
 })), ["raw_check"]);
+/** 本轮配置入口只显式开启发布，不扩展卸载或其他配置操作。 */
+export const packageConfigurationInputSchema = standardSchema(v.pipe(v.object({
+    path: v.pipe(v.string(), v.nonEmpty(), v.description("蓝图中已登记的包路径。")),
+    publication: v.optional(v.boolean(), false),
+    dryRun: v.optional(v.boolean(), false),
+}), v.rawCheck(({ dataset, addIssue }) => {
+    if (dataset.typed && !dataset.value.publication)
+        addIssue({ message: "请通过 --publication 明确开启发布。" });
+})), ["raw_check"]);

package/dist/input-validation.d.ts

@@ -0,0 +1,43 @@
+import { type CliPreset } from "./preset-catalog.ts";
+export type InitializationInputIssue = {
+    readonly code: "PRESET_UNKNOWN" | "FIXED_TOPOLOGY_OVERRIDE" | "INVALID_PACKAGE_NAME" | "INVALID_PACKAGE_PATH" | "RESERVED_PACKAGE_PATH" | "INVALID_PACKAGE_SCOPE" | "INVALID_REPOSITORY_SCOPE" | "CONFLICTING_PACKAGE_IDENTITY";
+};
+export type PackageAdditionInputIssue = {
+    readonly code: "PRESET_UNKNOWN" | "PRESET_NOT_ADDABLE" | "INVALID_PACKAGE_NAME" | "INVALID_PACKAGE_PATH" | "RESERVED_PACKAGE_PATH" | "INVALID_LINK_FROM" | "RESERVED_LINK_FROM" | "UNKNOWN_LINK_FROM" | "UNSUPPORTED_LINK";
+};
+type InitializationInput = {
+    readonly preset: string;
+    readonly targetDir: string;
+    readonly overrides?: {
+        readonly name?: string;
+        readonly path?: string;
+        readonly scope?: string;
+    };
+};
+export type ValidInitializationInput = {
+    readonly preset: CliPreset;
+    readonly repositoryName: string;
+    readonly defaultPackageScope: string;
+};
+export type InitializationInputValidation = {
+    readonly status: "valid";
+    readonly value: ValidInitializationInput;
+} | {
+    readonly status: "input-invalid";
+    readonly issues: readonly InitializationInputIssue[];
+};
+export declare function validateInitializationInput(input: InitializationInput): InitializationInputValidation;
+export declare function validatePackageAdditionInput(input: {
+    readonly preset: string;
+    readonly packageLeafName: string;
+    readonly packagePath?: string;
+    readonly linkFrom?: readonly string[];
+}): {
+    readonly status: "valid";
+    readonly preset: CliPreset;
+    readonly linkFrom: readonly string[];
+} | {
+    readonly status: "input-invalid";
+    readonly issues: readonly PackageAdditionInputIssue[];
+};
+export {};