@ykdz/template 0.0.35 → 0.0.37

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

@@ -6,6 +6,98 @@ const operationPath = (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;
+}
 export function assertPackageContribution(contribution, provenance = {}) {
     if (contribution.definition.name !== contribution.manifest.name) {
         throw new Error("Package Contribution manifest name must match its Package Definition");

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -5,7 +5,7 @@ nodeLinker: isolated
 
 autoInstallPeers: false
 
-injectWorkspacePackages: true
+injectWorkspacePackages: false
 
 dedupeInjectedDeps: false
 
@@ -21,9 +21,9 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
-  "@devcontainers/cli": 0.88.0
+  "@devcontainers/cli": 0.89.0
   "@hono/node-server": ^2.0.12
-  "@playwright/test": ^1.61.1
+  "@playwright/test": ^1.62.1
   "@tailwindcss/vite": ^4.3.3
   "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
@@ -32,30 +32,35 @@ catalog:
   "@vue/devtools-api": ^8.1.5
   "@vue/tsconfig": ^0.9.1
   commander: ^15.0.0
-  drizzle-kit: 1.0.0-rc.4
-  drizzle-orm: 1.0.0-rc.4
-  execa: ^10.0.0
-  hono: ^4.12.31
+  drizzle-kit: 1.0.0-rc.5-ab785fc
+  drizzle-orm: 1.0.0-rc.5-ab785fc
+  execa: ^10.0.1
+  hono: ^4.13.3
   node-diff3: ^3.2.1
-  oxfmt: ^0.58.0
-  oxlint: ^1.73.0
+  npm: 12.2.0
+  oxfmt: ^0.71.0
+  oxlint: ^1.77.0
   oxlint-tsgolint: ^7.0.2001
   semver: ^7.8.5
   "@types/semver": ^7.7.1
+  smol-toml: ^1.8.0
+  spdx-expression-parse: ^5.0.0
+  "@types/spdx-expression-parse": ^4.0.0
   pinia: ^4.0.2
-  srvx: ^0.12.1
-  tailwindcss: ^4.3.2
+  srvx: ^1.0.0
+  tailwindcss: ^4.3.3
+  tar: ^7.5.22
   telefunc: ^0.2.22
-  turbo: 2.10.5
+  turbo: 2.11.7
   typescript: npm:@typescript/typescript6@^6.0.2
   typescript-7: npm:typescript@^7.0.2
   valibot: ^1.4.2
-  vite: ^8.1.5
+  vite: ^8.2.0
   vike: ^0.4.260
   vike-vue: ^0.9.12
-  vitest: ^4.1.10
-  vue: ^3.5.39
-  vue-tsc: ^3.3.6
+  vitest: ^5.0.0
+  vue: ^3.5.40
+  vue-tsc: ^3.3.9
   yaml: ^2.9.0
 
 catalogs:

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

@@ -1,18 +1,76 @@
 import type { PackageContribution } from "./package-contribution.ts";
-import type { ProjectBlueprintV2 } from "./project-blueprint-v2.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 projectName: string;
-    readonly scope: 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;
     };
 };
-/** A side-effect-free Built-in Preset planner. */
-export type BuiltInPresetDefinition = {
+/** An in-memory plan tagged with the stable adapter that can replay it. */
+export type PlannedPackageContribution = PackageContribution & {
+    readonly planningIdentity: string;
+};
+/** Narrow access to initial sibling packages, keyed by stable adapter identity. */
+export type InitialPackageDefinitionLookup = {
+    require(identity: string): PackageDefinition;
+};
+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;
+};
+/**
+ * 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;
+};
+/** 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;
+};
+type BuiltInPresetDefinitionBase = {
     readonly metadata: {
         readonly name: string;
         readonly title: string;
@@ -22,13 +80,8 @@ export type BuiltInPresetDefinition = {
     readonly source: TemplateSourceHandle;
     /** The owned planner source inspected by the Template Boundary Check. */
     readonly plannerSourceFile: string;
-    blueprint(context: GenerationContext): ProjectBlueprintV2;
-    planInitialization(context: GenerationContext): PackageContribution;
-    /**
-     * Multi-package Definitions expose their complete owned topology directly,
-     * while single-package Definitions keep the compact tracer interface.
-     */
-    planInitializationContributions?(context: GenerationContext): readonly PackageContribution[];
+    /** 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;
@@ -38,5 +91,21 @@ export type BuiltInPresetDefinition = {
         readonly context: GenerationContext;
         readonly packageLeafName: string;
         readonly packagePath: string;
-    }): PackageContribution;
+    }): PlannedPackageContribution;
+};
+type ConfigurablePrimaryPackagePresetDefinition = BuiltInPresetDefinitionBase & {
+    readonly initialPrimaryPackage: InitialPrimaryPackageCapability;
+    readonly blueprint?: never;
+    readonly planInitialization?: never;
+    readonly planInitializationContributions?: never;
 };
+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[];
+};
+/** 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 +1,16 @@
-export {};
+/**
+ * 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,
+    };
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 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 PackageDefinition = {
+    readonly name: string;
+    readonly path: string;
+    readonly role: PackageRole;
+};
+/** Opaque durable identity assigned once when a Package Definition is created. */
+export type PackageDefinitionId = `package-${string}`;
+export type PersistedPackageDefinition = PackageDefinition & {
+    readonly packageDefinitionId: PackageDefinitionId;
+};
+export type PackageLinkIntent = {
+    readonly consumerPackagePath: string;
+    readonly providerPackagePath: string;
+};
+export type ProjectBlueprint = {
+    readonly schemaVersion: 3;
+    readonly packages: readonly PersistedPackageDefinition[];
+    readonly packageLinkIntents?: readonly PackageLinkIntent[];
+};
+/** Preset-owned topology before Foundation assigns durable package identities. */
+export type ProjectBlueprintDraft = {
+    readonly schemaVersion: 3;
+    readonly packages: readonly PackageDefinition[];
+    readonly packageLinkIntents?: readonly PackageLinkIntent[];
+};
+export type BlueprintValidationIssue = {
+    readonly path: string;
+    readonly message: string;
+};
+export type BlueprintValidationResult = {
+    readonly ok: true;
+    readonly value: ProjectBlueprint;
+} | {
+    readonly ok: false;
+    readonly issues: readonly BlueprintValidationIssue[];
+};
+/** 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. */
+export declare function assertProjectBlueprintDraft(value: ProjectBlueprintDraft): ProjectBlueprintDraft;
+export declare function assertProjectBlueprint(value: unknown): ProjectBlueprint;
+export {};

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

@@ -0,0 +1,271 @@
+import { isBuiltin } from "node:module";
+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"),
+};
+function packageDefinitionMessage(issue) {
+    return issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
+        ? unknownBlueprintField
+        : "Package Definition must be an object";
+}
+const packageDefinitionSchema = v.strictObject({
+    packageDefinitionId: v.string("Package Definition ID must use the package-<sha256> format"),
+    ...packageDefinitionEntries,
+}, packageDefinitionMessage);
+const packageLinkIntentSchema = v.strictObject({
+    consumerPackagePath: v.string("Package Link Intent consumer Package Path must be a string"),
+    providerPackagePath: v.string("Package Link Intent provider Package Path must be a string"),
+}, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
+    ? unknownBlueprintField
+    : "Package Link Intent must be an object");
+const projectBlueprintSchema = v.strictObject({
+    schemaVersion: v.literal(3, (issue) => `Unsupported Local Template Metadata schema version ${String(issue.input)}; expected 3`),
+    packages: v.array(packageDefinitionSchema, "Package Definitions must be an array"),
+    packageLinkIntents: v.optional(v.array(packageLinkIntentSchema, "Package Link Intents must be an array")),
+}, (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 blueprintIssuePath(issue) {
+    let result = ".";
+    for (const item of issue.path ?? []) {
+        if (typeof item.key === "number") {
+            result += `[${item.key}]`;
+        }
+        else if (typeof item.key === "string") {
+            result += `${result === "." ? "" : "."}${item.key}`;
+        }
+    }
+    return result;
+}
+function blueprintStructureMessage(issue) {
+    if (issue.type !== "strict_object" ||
+        issue.path?.at(-1)?.origin !== "key" ||
+        issue.input !== undefined) {
+        return issue.message;
+    }
+    const path = blueprintIssuePath(issue);
+    if (path === ".schemaVersion") {
+        return "Unsupported Local Template Metadata schema version undefined; expected 3";
+    }
+    if (path === ".packages")
+        return "Package Definitions must be an array";
+    if (path.endsWith(".name"))
+        return "Package name must be a string";
+    if (path.endsWith(".packageDefinitionId")) {
+        return "Package Definition ID must use the package-<sha256> format";
+    }
+    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 === ".packageLinkIntents") {
+        return "Package Link Intents must be an array";
+    }
+    if (path.endsWith(".consumerPackagePath")) {
+        return "Package Link Intent consumer Package Path must be a string";
+    }
+    if (path.endsWith(".providerPackagePath")) {
+        return "Package Link Intent provider Package Path must be a string";
+    }
+    return issue.message;
+}
+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)) {
+            issues.push({
+                path: `${itemPath}.name`,
+                message: "Package name must be a valid npm package name for new packages",
+            });
+        }
+        if (pathValidation.reservedWorkspaceCollection !== undefined) {
+            issues.push({
+                path: `${itemPath}.path`,
+                message: `Package Path ${definition.path} uses reserved workspace collection ${pathValidation.reservedWorkspaceCollection}`,
+            });
+        }
+        else if (!pathValidation.hasValidShape) {
+            issues.push({
+                path: `${itemPath}.path`,
+                message: "Package Path must be exactly two safe path segments",
+            });
+        }
+    }
+    for (const [property, label] of [
+        ["name", "Package name"],
+        ["path", "Package Path"],
+    ]) {
+        const seen = new Set();
+        for (const definition of blueprint.packages) {
+            const member = definition[property];
+            if (seen.has(member)) {
+                issues.push({
+                    path: ".packages",
+                    message: `${label} must be unique: ${member}`,
+                });
+            }
+            seen.add(member);
+        }
+    }
+    const paths = new Set(blueprint.packages.map((definition) => definition.path));
+    const links = new Set();
+    for (const [index, intent] of (blueprint.packageLinkIntents ?? []).entries()) {
+        const itemPath = `.packageLinkIntents[${index}]`;
+        if (!paths.has(intent.consumerPackagePath)) {
+            issues.push({
+                path: `${itemPath}.consumerPackagePath`,
+                message: "Package Link Intent references an unknown consumer package",
+            });
+        }
+        if (!paths.has(intent.providerPackagePath)) {
+            issues.push({
+                path: `${itemPath}.providerPackagePath`,
+                message: "Package Link Intent references an unknown provider package",
+            });
+        }
+        if (intent.consumerPackagePath === intent.providerPackagePath) {
+            issues.push({
+                path: itemPath,
+                message: "Package Link Intent cannot link a package to itself",
+            });
+        }
+        const key = `${intent.consumerPackagePath}\u0000${intent.providerPackagePath}`;
+        if (links.has(key)) {
+            issues.push({
+                path: itemPath,
+                message: "Package Link Intent must be unique",
+            });
+        }
+        links.add(key);
+    }
+    return issues;
+}
+function validatePersistedPackageIds(blueprint) {
+    const issues = [];
+    const seen = new Set();
+    for (const [index, definition] of blueprint.packages.entries()) {
+        if (!/^package-[a-f0-9]{64}$/.test(definition.packageDefinitionId)) {
+            issues.push({
+                path: `.packages[${index}].packageDefinitionId`,
+                message: "Package Definition ID must use the package-<sha256> format",
+            });
+        }
+        if (seen.has(definition.packageDefinitionId)) {
+            issues.push({
+                path: ".packages",
+                message: `Package Definition ID must be unique: ${definition.packageDefinitionId}`,
+            });
+        }
+        seen.add(definition.packageDefinitionId);
+    }
+    return issues;
+}
+/** Validates persisted metadata before it is used to plan or render changes. */
+export function validateProjectBlueprint(value) {
+    const parsed = v.safeParse(projectBlueprintSchema, value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            issues: parsed.issues.map((issue) => ({
+                path: blueprintIssuePath(issue),
+                message: blueprintStructureMessage(issue),
+            })),
+        };
+    }
+    const blueprint = {
+        schemaVersion: parsed.output.schemaVersion,
+        packages: parsed.output.packages,
+        ...(parsed.output.packageLinkIntents === undefined
+            ? {}
+            : { packageLinkIntents: parsed.output.packageLinkIntents }),
+    };
+    const issues = [
+        ...validateBlueprintTopologySemantics(blueprint),
+        ...validatePersistedPackageIds(blueprint),
+    ];
+    return issues.length === 0
+        ? { ok: true, value: blueprint }
+        : { ok: false, issues };
+}
+/** Validates preset-owned topology before any persisted identity is assigned. */
+export function assertProjectBlueprintDraft(value) {
+    const issues = validateBlueprintTopologySemantics(value);
+    if (issues.length > 0) {
+        throw new Error(issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n"));
+    }
+    return value;
+}
+export function assertProjectBlueprint(value) {
+    const result = validateProjectBlueprint(value);
+    if (!result.ok) {
+        throw new Error(result.issues
+            .map((issue) => `${issue.path}: ${issue.message}`)
+            .join("\n"));
+    }
+    return result.value;
+}

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

@@ -61,8 +61,9 @@ export type ProjectCheckWorkflowDiagnosticOptions = {
     readonly diagnosticArtifacts?: readonly unknown[] | undefined;
 };
 type ProjectCheckWorkflowOptions = ProjectCheckWorkflowDiagnosticOptions & {
-    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
-    readonly hasDeploymentTask?: boolean | undefined;
+    readonly deploymentCheck?: {
+        readonly environmentNeeds: readonly DeploymentEnvironmentNeed[];
+    } | undefined;
     readonly capability?: CiCapability | undefined;
     readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
     readonly taskLayer?: PnpmTaskLayer | undefined;
@@ -71,8 +72,9 @@ type ProjectCheckWorkflowOptions = ProjectCheckWorkflowDiagnosticOptions & {
 export declare function projectCheckWorkflowPlan(options: ProjectCheckWorkflowOptions): ProjectCheckWorkflowPlan;
 /** Selects a complete Foundation-owned workflow Template Source. */
 export declare function projectCheckWorkflowTemplateSource(options: ProjectCheckWorkflowDiagnosticOptions & {
-    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
-    readonly hasDeploymentTask?: boolean | undefined;
+    readonly deploymentCheck?: {
+        readonly environmentNeeds: readonly DeploymentEnvironmentNeed[];
+    } | undefined;
 }): ".github/workflows/check.yml" | ".github/workflows/check-diagnostics.yml" | ".github/workflows/check-deployment.yml" | ".github/workflows/check-deployment-diagnostics.yml";
 /** Limited, validated facts for static Foundation diagnostic staging. */
 export declare function projectCheckWorkflowTemplateReplacements(options: ProjectCheckWorkflowDiagnosticOptions): Record<string, string>;

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

@@ -26,8 +26,8 @@ export function projectCheckWorkflowPlan(options) {
         ...options.environmentPreparation,
     };
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
-    const hasDeploymentTask = options.hasDeploymentTask === true;
-    const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
+    const hasDeploymentTask = options.deploymentCheck !== undefined;
+    const needsDocker = (options.deploymentCheck?.environmentNeeds ?? []).some((need) => need.kind === "docker-engine");
     if (hasDeploymentTask && !needsDocker) {
         throw new Error("Deployment Check requires a Docker environment need");
     }
@@ -74,8 +74,8 @@ export function projectCheckWorkflowPlan(options) {
 }
 /** Selects a complete Foundation-owned workflow Template Source. */
 export function projectCheckWorkflowTemplateSource(options) {
-    const hasDeploymentTask = options.hasDeploymentTask === true;
-    const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
+    const hasDeploymentTask = options.deploymentCheck !== undefined;
+    const needsDocker = (options.deploymentCheck?.environmentNeeds ?? []).some((need) => need.kind === "docker-engine");
     if (hasDeploymentTask && !needsDocker) {
         throw new Error("Deployment Check requires a Docker environment need");
     }