@ykdz/template 0.0.41 → 0.1.0-experimental.0

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

@@ -0,0 +1,42 @@
+/** 内容身份只由来源命名空间、所属原生包名和公开导出入口确定。 */
+export type ContentIdentity = Readonly<{
+    readonly namespace: string;
+    readonly packageName: string;
+    readonly exportPath: string;
+}>;
+export type ContentKind = "preset" | "reference";
+/** 选择可使用展示别名，或提供完整规范身份。 */
+export type ContentSelector = ContentIdentity | string | Readonly<{
+    alias: string;
+    namespace?: string;
+}>;
+/** 装载后的成员保留原定义对象，并记录本次实际公开入口。 */
+export type LoadedContentMember<Definition = unknown, Kind extends ContentKind = ContentKind> = Readonly<{
+    readonly identity: ContentIdentity;
+    readonly kind: Kind;
+    readonly alias: string;
+    readonly definition: Definition;
+    readonly source: Readonly<{
+        readonly specifier: string;
+        readonly moduleURL: string;
+        readonly manifestURL: string;
+    }>;
+}>;
+export type ContentIndex<Member extends LoadedContentMember = LoadedContentMember> = Readonly<{
+    readonly members: readonly Member[];
+    resolve<Kind extends Member["kind"]>(selector: ContentSelector, expectedKind: Kind): Member & {
+        readonly kind: Kind;
+    };
+    fromDefinition<Kind extends Member["kind"]>(definition: unknown, expectedKind: Kind, options?: Readonly<{
+        readonly namespace?: string;
+    }>): Member & {
+        readonly kind: Kind;
+    };
+}>;
+/** 使用JSON三元组作为Map键，避免分隔符碰撞和附加身份维度。 */
+export declare function contentIdentityKey(identity: ContentIdentity): string;
+export declare function contentIdentityLabel(identity: ContentIdentity): string;
+export declare function isContentIdentity(value: unknown): value is ContentIdentity;
+export declare function assertContentIdentity(value: unknown): asserts value is ContentIdentity;
+/** 创建纯索引；不访问磁盘、不解析模块，也不隐式补充未登记成员。 */
+export declare function createContentIndex<Member extends LoadedContentMember>(members: readonly Member[]): ContentIndex<Member>;

package/node_modules/@ykdz/template-core/dist/content-identity.js

@@ -0,0 +1,117 @@
+/** 使用JSON三元组作为Map键，避免分隔符碰撞和附加身份维度。 */
+export function contentIdentityKey(identity) {
+    assertContentIdentity(identity);
+    return JSON.stringify([
+        identity.namespace,
+        identity.packageName,
+        identity.exportPath,
+    ]);
+}
+export function contentIdentityLabel(identity) {
+    return `${identity.namespace}:${identity.packageName}#${identity.exportPath}`;
+}
+export function isContentIdentity(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.namespace === "string" &&
+        record.namespace.trim().length > 0 &&
+        typeof record.packageName === "string" &&
+        record.packageName.trim().length > 0 &&
+        typeof record.exportPath === "string" &&
+        (record.exportPath === "." || record.exportPath.startsWith("./")));
+}
+export function assertContentIdentity(value) {
+    if (!isContentIdentity(value)) {
+        throw new Error("内容身份必须包含命名空间、包名和公开导出入口");
+    }
+}
+/** 创建纯索引；不访问磁盘、不解析模块，也不隐式补充未登记成员。 */
+export function createContentIndex(members) {
+    const identities = new Map();
+    const aliases = new Map();
+    const definitions = new Map();
+    for (const member of members) {
+        assertContentIdentity(member.identity);
+        if (member.kind !== "preset" && member.kind !== "reference") {
+            throw new Error(`内容${contentIdentityLabel(member.identity)}的种类无效`);
+        }
+        if (typeof member.alias !== "string" || member.alias.trim().length === 0) {
+            throw new Error(`内容${contentIdentityLabel(member.identity)}缺少有效别名`);
+        }
+        const key = contentIdentityKey(member.identity);
+        const previous = identities.get(key);
+        if (previous !== undefined) {
+            const cause = previous.source.moduleURL === member.source.moduleURL
+                ? "重复规范身份"
+                : "同一规范身份存在多个未明确选择的来源修订";
+            throw new Error(`${cause}：${contentIdentityLabel(member.identity)}`);
+        }
+        identities.set(key, member);
+        const aliasMembers = aliases.get(member.alias) ?? [];
+        aliasMembers.push(member);
+        aliases.set(member.alias, aliasMembers);
+        if (typeof member.definition === "object" && member.definition !== null) {
+            const definitionMembers = definitions.get(member.definition) ?? [];
+            definitionMembers.push(member);
+            definitions.set(member.definition, definitionMembers);
+        }
+    }
+    const requireKind = (member, expectedKind) => {
+        if (member.kind !== expectedKind) {
+            throw new Error(`内容${contentIdentityLabel(member.identity)}种类不符：需要${expectedKind}，实际为${member.kind}`);
+        }
+        return member;
+    };
+    const resolve = (selector, expectedKind) => {
+        if (isContentIdentity(selector)) {
+            const member = identities.get(contentIdentityKey(selector));
+            if (member === undefined) {
+                throw new Error(`规范内容不存在：${contentIdentityLabel(selector)}`);
+            }
+            return requireKind(member, expectedKind);
+        }
+        const aliasSelector = typeof selector === "string" ? { alias: selector } : selector;
+        if (typeof aliasSelector.alias !== "string" ||
+            aliasSelector.alias.trim().length === 0) {
+            throw new Error("内容别名不能为空");
+        }
+        const candidates = (aliases.get(aliasSelector.alias) ?? []).filter((member) => aliasSelector.namespace === undefined ||
+            member.identity.namespace === aliasSelector.namespace);
+        if (candidates.length === 0) {
+            throw new Error(`内容别名不存在：${aliasSelector.alias}`);
+        }
+        if (candidates.length > 1) {
+            const choices = candidates
+                .map((member) => contentIdentityLabel(member.identity))
+                .join("、");
+            throw new Error(`内容别名存在歧义：${aliasSelector.alias}（${choices}）`);
+        }
+        return requireKind(candidates[0], expectedKind);
+    };
+    const fromDefinition = (definition, expectedKind, options) => {
+        if (typeof definition !== "object" || definition === null) {
+            throw new Error("内容定义未由显式集合装载");
+        }
+        const matchingKind = (definitions.get(definition) ?? []).filter((member) => member.kind === expectedKind);
+        const inNamespace = options?.namespace === undefined
+            ? []
+            : matchingKind.filter((member) => member.identity.namespace === options.namespace);
+        const candidates = inNamespace.length > 0 ? inNamespace : matchingKind;
+        if (candidates.length === 0) {
+            throw new Error("内容定义未由显式集合装载");
+        }
+        if (candidates.length > 1) {
+            const namespaces = new Set(candidates.map((member) => member.identity.namespace));
+            const cause = namespaces.size > 1
+                ? "同一内容定义属于多个命名空间"
+                : "同一内容定义关联多个规范入口";
+            throw new Error(`${cause}，必须明确来源：${candidates
+                .map((member) => contentIdentityLabel(member.identity))
+                .join("、")}`);
+        }
+        return candidates[0];
+    };
+    return Object.freeze({ members: [...members], resolve, fromDefinition });
+}

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

@@ -0,0 +1,28 @@
+import * as v from "valibot";
+import type { GenerationRecord, PackageCreationInput } from "./workspace-strategy.ts";
+/** schema4 只保存后续操作所需的事实；蓝图仍是包定义的唯一来源。 */
+export declare const generationRecordSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<4, undefined>;
+    readonly strategyIdentity: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly strategyState: v.UnknownSchema;
+    readonly packages: v.ArraySchema<v.StrictObjectSchema<{
+        readonly contentIdentity: v.StrictObjectSchema<{
+            readonly namespace: v.StringSchema<undefined>;
+            readonly packageName: v.StringSchema<undefined>;
+            readonly exportPath: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly createdBy: v.PicklistSchema<["initialization", "addition", "shared-dependency"], undefined>;
+        readonly packageDefinitionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly creationInput: v.NullableSchema<v.UnknownSchema, undefined>;
+        readonly configuration: v.NullableSchema<v.UnknownSchema, undefined>;
+        readonly bindings: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly nodeInstances: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    readonly presetSelections: v.ArraySchema<v.StrictObjectSchema<{
+        readonly namespace: v.StringSchema<undefined>;
+        readonly packageName: v.StringSchema<undefined>;
+        readonly exportPath: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/** 按公开 schema4 结构解析；策略状态由 workspace owner 继续校验。 */
+export declare function parseGenerationRecordStructure<CreationInput extends PackageCreationInput = PackageCreationInput>(value: unknown): GenerationRecord<CreationInput>;

package/node_modules/@ykdz/template-core/dist/generation-record.js

@@ -0,0 +1,45 @@
+import * as v from "valibot";
+const contentIdentitySchema = v.strictObject({
+    namespace: v.string(),
+    packageName: v.string(),
+    exportPath: v.string(),
+});
+/** schema4 只保存后续操作所需的事实；蓝图仍是包定义的唯一来源。 */
+export const generationRecordSchema = v.strictObject({
+    schemaVersion: v.literal(4),
+    strategyIdentity: v.pipe(v.string(), v.minLength(1)),
+    strategyState: v.unknown(),
+    packages: v.array(v.strictObject({
+        contentIdentity: contentIdentitySchema,
+        createdBy: v.picklist([
+            "initialization",
+            "addition",
+            "shared-dependency",
+        ]),
+        packageDefinitionId: v.pipe(v.string(), v.regex(/^package-[a-f0-9]{64}$/)),
+        creationInput: v.nullable(v.unknown()),
+        configuration: v.nullable(v.unknown()),
+        bindings: v.record(v.string(), v.string()),
+    })),
+    nodeInstances: v.record(v.string(), v.string()),
+    presetSelections: v.array(contentIdentitySchema),
+});
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** 按公开 schema4 结构解析；策略状态由 workspace owner 继续校验。 */
+export function parseGenerationRecordStructure(value) {
+    if (isRecord(value) && value.schemaVersion !== 4) {
+        throw new Error(`不支持的生成记录 schema ${String(value.schemaVersion)}；当前只支持 schema4`);
+    }
+    if (isRecord(value) &&
+        Array.isArray(value.packages) &&
+        value.packages.some((entry) => isRecord(entry) && !Object.hasOwn(entry, "configuration"))) {
+        throw new Error("生成记录不符合 schema4 结构：缺少实例现行配置");
+    }
+    const parsed = v.safeParse(generationRecordSchema, value);
+    if (!parsed.success) {
+        throw new Error("生成记录不符合 schema4 结构");
+    }
+    return parsed.output;
+}

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

@@ -1,89 +1,11 @@
-import { type CiDiagnosticArtifactDeclaration } from "./ci-diagnostic-artifact.ts";
-import type { DevelopmentContainerToolLayer } from "./development-container-tool-layer.ts";
-import type { EditorCustomizationCapability } from "./editor-customization.ts";
-import type { CheckEnvironmentNeed, DeploymentEnvironmentNeed } from "./module-graph.ts";
 import type { PackageDefinition } from "./project-blueprint.ts";
-import type { DependencyMaintenancePolicy } from "./project-github.ts";
-import type { RenderOperation, TemplateSourceHandle } from "./renderer.ts";
-export type FoundationContribution = {
-    /** Closed root-owned Vue-Hono page/API browser acceptance capability. */
-    readonly vueHonoJointE2e?: {
-        readonly kind: "vue-hono-joint-e2e";
-        readonly apiPackageName: string;
-    };
-    readonly databasePreparation?: {
-        readonly kind: "sqlite-database-preparation";
-        readonly migrationPackageName: string;
-        readonly consumers: readonly {
-            readonly kind: "application-dev" | "database-test" | "application-e2e";
-            readonly packageName: string;
-        }[];
-    };
-    /** A closed repository-context deployment capability projected by Foundation. */
-    readonly deploymentCheck?: {
-        readonly kind: "application-container-with-database-migrations";
-        readonly applicationPackageName: string;
-        readonly databasePackageName: string;
-        readonly migrationPackageName: string;
-        readonly environmentNeeds: readonly DeploymentEnvironmentNeed[];
-        readonly sources: {
-            readonly checker: FoundationTemplateAssetSource;
-            readonly controlScript: FoundationTemplateAssetSource;
-            readonly dockerfile: FoundationTemplateAssetSource;
-            readonly dockerIgnore: FoundationTemplateAssetSource;
-            readonly shellCheckDockerfile: FoundationTemplateAssetSource;
-        };
-    };
-    /** Closed publication capability consumed only by coordinated root policy. */
-    readonly npmPublication?: {
-        readonly kind: "public-cli-candidate";
-    };
-    /** Toolchains the Foundation must install and project into coordinated root files. */
-    readonly toolchains: {
-        readonly rust?: {
-            readonly toolchain: string;
-            readonly components: readonly ("rustfmt" | "clippy")[];
-            readonly configurationSource: FoundationTemplateAssetSource;
-        };
-    };
-    /** Editor capabilities the Foundation must project into its coordinated editor files. */
-    readonly editorCapabilities: readonly EditorCustomizationCapability[];
-    /** Ecosystems and paths whose maintenance belongs in the coordinated root policy. */
-    readonly dependencyMaintenance: DependencyMaintenancePolicy;
-    /** Explicit dependency on the Foundation-owned TypeScript policy Package. */
-    readonly typescriptConfigurationPackage?: {
-        readonly dependency: "required";
-    };
-    /** Workspace membership patterns contributed by package boundaries. */
-    readonly workspacePackageGlobs?: readonly string[];
-    /** Dependency Catalog entries required by package-owned manifests. */
-    readonly dependencyCatalog?: Readonly<Record<string, string>>;
-    /** Source-backed Development Container capabilities coordinated by Foundation. */
-    readonly developmentContainerToolLayers?: readonly DevelopmentContainerToolLayer[] | undefined;
-};
-export type FoundationTemplateAssetSource = {
-    readonly source: TemplateSourceHandle;
-    readonly from: string;
-};
-/** A preset-agnostic package-sized part of a Generated Repository Plan. */
+import type { RenderOperation } from "./renderer.ts";
+/** 生成仓库计划中由单个包拥有的部分。 */
 export type PackageContribution = {
     readonly definition: PackageDefinition;
-    readonly manifest: Readonly<Record<string, unknown>>;
-    readonly exposure: {
-        readonly exports: Readonly<Record<string, unknown>>;
-        readonly imports: Readonly<Record<string, unknown>>;
-    };
     readonly operations: readonly RenderOperation[];
-    /** Typed requirements consumed by the Foundation for coordinated root outputs. */
-    readonly foundation: FoundationContribution;
-    readonly environmentNeeds: readonly CheckEnvironmentNeed[];
-    /** Closed native CI evidence owned by this Package Boundary. */
-    readonly ciDiagnosticArtifacts?: readonly CiDiagnosticArtifactDeclaration[];
 };
-/** Validates the portable executable name promised by a CLI Package Boundary. */
-export declare function validateCliCommandName(commandName: string, occupiedCommandNames?: readonly string[]): string;
-/** Validates command portability and uniqueness across one complete plan. */
-export declare function assertPackageContributionCommandNames(contributions: readonly PackageContribution[]): readonly PackageContribution[];
+/** 确保包贡献只写入自身的包边界。 */
 export declare function assertPackageContribution(contribution: PackageContribution, provenance?: {
     readonly definitionName?: string;
     readonly planner?: string;

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

@@ -1,123 +1,36 @@
-import { assertCiDiagnosticArtifactDeclaration, } from "./ci-diagnostic-artifact.js";
-const operationPath = (operation) => {
+import path from "node:path";
+function operationPath(operation) {
     if ("to" in operation)
         return operation.to;
     if ("path" in operation)
         return operation.path;
     return "";
-};
-const reservedSystemToolNames = new Set([
-    "aux",
-    "bash",
-    "bun",
-    "cmd",
-    "com1",
-    "com2",
-    "com3",
-    "com4",
-    "com5",
-    "com6",
-    "com7",
-    "com8",
-    "com9",
-    "con",
-    "corepack",
-    "deno",
-    "git",
-    "lpt1",
-    "lpt2",
-    "lpt3",
-    "lpt4",
-    "lpt5",
-    "lpt6",
-    "lpt7",
-    "lpt8",
-    "lpt9",
-    "node",
-    "nul",
-    "npm",
-    "npx",
-    "pnpm",
-    "powershell",
-    "prn",
-    "pwsh",
-    "sh",
-    "yarn",
-    "zsh",
-]);
-/** Validates the portable executable name promised by a CLI Package Boundary. */
-export function validateCliCommandName(commandName, occupiedCommandNames = []) {
-    if (/[/\\]/u.test(commandName)) {
-        throw new Error(`CLI command name must not be a path; received ${JSON.stringify(commandName)}`);
-    }
-    if (/\p{White_Space}/u.test(commandName)) {
-        throw new Error(`CLI command name must not contain whitespace; received ${JSON.stringify(commandName)}`);
-    }
-    if (/\p{Control}/u.test(commandName)) {
-        throw new Error(`CLI command name must not contain a control character; received ${JSON.stringify(commandName)}`);
-    }
-    if (commandName.startsWith("-")) {
-        throw new Error(`CLI command name must not have a leading hyphen; received ${JSON.stringify(commandName)}`);
-    }
-    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(commandName)) {
-        throw new Error(`CLI command name must use lowercase ASCII letters, digits, and single hyphens; received ${JSON.stringify(commandName)}`);
-    }
-    if (reservedSystemToolNames.has(commandName)) {
-        throw new Error(`CLI command name is a reserved system tool; received ${JSON.stringify(commandName)}`);
-    }
-    if (occupiedCommandNames.includes(commandName)) {
-        throw new Error(`CLI command name is already used by another workspace package; received ${JSON.stringify(commandName)}`);
-    }
-    return commandName;
-}
-function manifestBinEntries(contribution) {
-    const bin = contribution.manifest.bin;
-    if (typeof bin !== "object" || bin === null || Array.isArray(bin)) {
-        return [];
-    }
-    return Object.entries(bin);
 }
-/** Validates command portability and uniqueness across one complete plan. */
-export function assertPackageContributionCommandNames(contributions) {
-    const commandOwner = new Map();
-    for (const contribution of contributions) {
-        const entries = manifestBinEntries(contribution);
-        for (const [commandName] of entries) {
-            const existingOwner = commandOwner.get(commandName);
-            try {
-                validateCliCommandName(commandName, [...commandOwner.keys()]);
-            }
-            catch (error) {
-                if (existingOwner !== undefined) {
-                    throw new Error(`CLI command name ${JSON.stringify(commandName)} from ${contribution.definition.name} is already used by ${existingOwner}`, { cause: error });
-                }
-                throw error;
-            }
-            commandOwner.set(commandName, contribution.definition.name);
-        }
-    }
-    return contributions;
+function isCanonicalRelativePath(value) {
+    return (value.length > 0 &&
+        !value.includes("\\") &&
+        !path.posix.isAbsolute(value) &&
+        path.posix.normalize(value) === value &&
+        value.split("/").every((segment) => segment.length > 0));
 }
+/** 确保包贡献只写入自身的包边界。 */
 export function assertPackageContribution(contribution, provenance = {}) {
-    if (contribution.definition.name !== contribution.manifest.name) {
-        throw new Error("Package Contribution manifest name must match its Package Definition");
-    }
-    const outsideOperation = contribution.operations.find((operation) => !operationPath(operation).startsWith(`${contribution.definition.path}/`));
+    const outsideOperation = contribution.operations.find((operation) => {
+        const target = operationPath(operation);
+        return (!isCanonicalRelativePath(target) ||
+            !target.startsWith(`${contribution.definition.path}/`));
+    });
     if (outsideOperation) {
         const target = operationPath(outsideOperation);
-        const rule = target.includes("/")
-            ? "Package Contribution may not write a sibling Package Boundary"
-            : "Package Contribution may not write a coordinated root output";
+        const rule = !isCanonicalRelativePath(target)
+            ? "Package Contribution must use a canonical relative output path"
+            : target.includes("/")
+                ? "Package Contribution may not write a sibling Package Boundary"
+                : "Package Contribution may not write a coordinated root output";
         const owner = provenance.definitionName === undefined
             ? ""
             : `${provenance.definitionName}: ${provenance.planner ?? "Package Contribution"} `;
         throw new Error(`${owner}${rule}; ${contribution.definition.path} attempted ${target}`);
     }
-    for (const artifact of contribution.ciDiagnosticArtifacts ?? []) {
-        const declaration = assertCiDiagnosticArtifactDeclaration(artifact);
-        if (declaration.owner.path !== contribution.definition.path) {
-            throw new Error(`CI Diagnostic Artifact owner must match its Package Contribution: ${contribution.definition.path}`);
-        }
-    }
     return contribution;
 }