@ykdz/template 0.0.33 → 0.0.36

package/node_modules/@ykdz/template-core/dist/module-graph.js

@@ -1,74 +1,156 @@
-export function checkEnvironmentNeedFact(need) {
-    switch (need.kind) {
-        case "playwright-browser-assets":
-            return { kind: need.kind, browser: need.browser, owner: need.owner };
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertExactKeys(value, allowedKeys, context) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.includes(key)) {
+            throw new Error(`${context} contains unknown field: ${key}`);
+        }
+    }
+}
+function parseComponentOwner(value, context) {
+    if (!isRecord(value)) {
+        throw new Error(`${context} must be a Component Owner`);
+    }
+    assertExactKeys(value, ["kind", "path"], context);
+    if (value.kind === "workspace-orchestration" && value.path === ".") {
+        return { kind: value.kind, path: value.path };
+    }
+    if (value.kind === "package-boundary" &&
+        typeof value.path === "string" &&
+        value.path.length > 0) {
+        return { kind: value.kind, path: value.path };
+    }
+    throw new Error(`${context} is not a supported Component Owner`);
+}
+function parseCheckEnvironmentNeed(value, context) {
+    if (!isRecord(value)) {
+        throw new Error(`${context} must be a Check Environment Need`);
+    }
+    switch (value.kind) {
+        case "playwright-browser-assets": {
+            assertExactKeys(value, ["kind", "browser", "owner"], context);
+            if (value.browser !== "chromium") {
+                throw new Error(`${context}.browser must be chromium`);
+            }
+            return {
+                kind: value.kind,
+                browser: value.browser,
+                owner: parseComponentOwner(value.owner, `${context}.owner`),
+            };
+        }
         case "shellcheck-command":
-            return { kind: need.kind, owner: need.owner };
-        case "rust-toolchain":
+            assertExactKeys(value, ["kind", "owner"], context);
+            return {
+                kind: value.kind,
+                owner: parseComponentOwner(value.owner, `${context}.owner`),
+            };
+        case "rust-toolchain": {
+            assertExactKeys(value, ["kind", "owner", "toolchain"], context);
+            if (value.toolchain !== "stable") {
+                throw new Error(`${context}.toolchain must be stable`);
+            }
             return {
-                kind: need.kind,
-                owner: need.owner,
-                toolchain: need.toolchain,
+                kind: value.kind,
+                owner: parseComponentOwner(value.owner, `${context}.owner`),
+                toolchain: value.toolchain,
             };
+        }
+        default:
+            throw new Error(`${context} has unsupported kind: ${String(value.kind)}`);
     }
 }
-export function checkEnvironmentNeedFromFact(fact) {
-    switch (fact.kind) {
+function parseDeploymentEnvironmentNeed(value, context) {
+    if (!isRecord(value)) {
+        throw new Error(`${context} must be a Deployment Environment Need`);
+    }
+    assertExactKeys(value, ["kind"], context);
+    if (value.kind !== "docker-engine") {
+        throw new Error(`${context} has unsupported kind: ${String(value.kind)}`);
+    }
+    return { kind: value.kind };
+}
+function componentOwnerIdentity(owner) {
+    return `${owner.kind}:${owner.path}`;
+}
+function checkEnvironmentNeedConflictKey(need) {
+    return `${need.kind}:${componentOwnerIdentity(need.owner)}`;
+}
+function checkEnvironmentNeedIdentity(need) {
+    switch (need.kind) {
         case "playwright-browser-assets":
-            return playwrightBrowserAssetsEnvironmentNeed({
-                browser: fact.browser,
-                owner: fact.owner,
-            });
+            return `${checkEnvironmentNeedConflictKey(need)}:browser=${need.browser}`;
         case "shellcheck-command":
-            return shellCheckEnvironmentNeed(fact.owner);
+            return checkEnvironmentNeedConflictKey(need);
         case "rust-toolchain":
-            return rustToolchainEnvironmentNeed(fact.owner);
+            return `${checkEnvironmentNeedConflictKey(need)}:toolchain=${need.toolchain}`;
+    }
+}
+function normalizeCheckEnvironmentNeeds(needs) {
+    const byIdentity = new Map();
+    const identityByConflictKey = new Map();
+    for (const [index, input] of needs.entries()) {
+        const need = parseCheckEnvironmentNeed(input, `check[${index}]`);
+        const identity = checkEnvironmentNeedIdentity(need);
+        const conflictKey = checkEnvironmentNeedConflictKey(need);
+        const previousIdentity = identityByConflictKey.get(conflictKey);
+        if (previousIdentity !== undefined && previousIdentity !== identity) {
+            throw new Error(`Check Environment Need ${conflictKey} has conflicting semantic parameters`);
+        }
+        identityByConflictKey.set(conflictKey, identity);
+        byIdentity.set(identity, need);
+    }
+    return [...byIdentity]
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([, need]) => need);
+}
+function normalizeDeploymentEnvironmentNeeds(needs) {
+    const byIdentity = new Map();
+    for (const [index, input] of needs.entries()) {
+        const need = parseDeploymentEnvironmentNeed(input, `deployment[${index}]`);
+        byIdentity.set(need.kind, need);
     }
+    return [...byIdentity]
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([, need]) => need);
 }
-export function deploymentEnvironmentNeedFact(need) {
-    return { kind: need.kind };
+/** Validates, deduplicates, and canonically orders durable Environment Needs. */
+export function normalizeEnvironmentNeeds(options) {
+    return {
+        schemaVersion: 1,
+        check: normalizeCheckEnvironmentNeeds(options.check),
+        deployment: normalizeDeploymentEnvironmentNeeds(options.deployment),
+    };
 }
-export function deploymentEnvironmentNeedFromFact(fact) {
-    if (fact.kind !== "docker-engine") {
-        throw new Error("Unsupported Deployment Environment Need fact.");
+/** Strict codec for Local Template Metadata consumed by Package Addition. */
+export function parseEnvironmentNeedsMetadata(value) {
+    if (!isRecord(value)) {
+        throw new Error("Environment Need metadata must be an object");
+    }
+    assertExactKeys(value, ["schemaVersion", "check", "deployment"], "$");
+    if (value.schemaVersion !== 1) {
+        throw new Error(`Unsupported Environment Need metadata schema version ${String(value.schemaVersion)}; expected 1`);
+    }
+    if (!Array.isArray(value.check)) {
+        throw new Error("$.check must be an array");
+    }
+    if (!Array.isArray(value.deployment)) {
+        throw new Error("$.deployment must be an array");
     }
-    return dockerEngineEnvironmentNeed();
+    return normalizeEnvironmentNeeds({
+        check: value.check,
+        deployment: value.deployment,
+    });
 }
 export function rustToolchainEnvironmentNeed(owner) {
     return {
         kind: "rust-toolchain",
         owner,
         toolchain: "stable",
-        nextStep: {
-            id: "install-rust-toolchain",
-            label: "Install Rust toolchain",
-            command: "rustup",
-            args: [
-                "toolchain",
-                "install",
-                "stable",
-                "--component",
-                "rustfmt",
-                "--component",
-                "clippy",
-            ],
-            display: "rustup toolchain install stable --component rustfmt --component clippy",
-            machineVerifiable: false,
-        },
     };
 }
 export function dockerEngineEnvironmentNeed() {
-    return {
-        kind: "docker-engine",
-        preparation: {
-            id: "verify-docker-engine",
-            label: "Verify Docker engine",
-            command: "docker",
-            args: ["version", "--format", "{{.Server.Version}}"],
-            display: "docker version --format {{.Server.Version}}",
-            machineVerifiable: true,
-        },
-    };
+    return { kind: "docker-engine" };
 }
 export const qualityTaskVocabulary = [
     "boundaries",
@@ -92,8 +174,8 @@ export function renderTurboRunCommand(taskNames, args = [], options = {}) {
         ...(options.taskPrefix ? ["--log-prefix=task"] : []),
     ].join(" ");
 }
-export function renderRootCheckCommand() {
-    return renderTurboRunCommand(qualityTaskVocabulary, [], {
+export function renderRootCheckCommand(additionalTasks = []) {
+    return renderTurboRunCommand([...qualityTaskVocabulary, ...additionalTasks], [], {
         continueAfterFailure: true,
         taskPrefix: true,
     });
@@ -108,65 +190,16 @@ export function renderFixCommand() {
         taskPrefix: true,
     });
 }
-function playwrightBrowserInstallArgs(need, options = {}) {
-    const installArgs = [
-        "exec",
-        "playwright",
-        "install",
-        ...(options.withDeps ? ["--with-deps"] : []),
-        need.browser,
-    ];
-    if (need.owner.kind === "package-boundary" && need.owner.path !== ".") {
-        return ["--filter", `./${need.owner.path}`, ...installArgs];
-    }
-    return installArgs;
-}
-export function renderPlaywrightBrowserInstallCommand(need, options = {}) {
-    if (need.kind !== "playwright-browser-assets") {
-        throw new Error("Playwright install requires browser assets.");
-    }
-    return ["pnpm", ...playwrightBrowserInstallArgs(need, options)].join(" ");
-}
-export function playwrightBrowserAssetsNextStepDescriptor(owner) {
-    if (owner.kind === "package-boundary" && owner.path !== ".") {
-        return {
-            id: `install-${owner.path.replaceAll("/", "-")}-playwright-browsers`,
-            label: `Install Playwright browser assets for ${owner.path} package`,
-        };
-    }
-    return {
-        id: "install-workspace-playwright-browsers",
-        label: "Install Playwright browser assets for workspace",
-    };
-}
 export function playwrightBrowserAssetsEnvironmentNeed(options) {
-    const args = playwrightBrowserInstallArgs(options);
-    const descriptor = playwrightBrowserAssetsNextStepDescriptor(options.owner);
     return {
         kind: "playwright-browser-assets",
         browser: options.browser,
         owner: options.owner,
-        nextStep: {
-            id: options.id ?? descriptor.id,
-            label: options.label ?? descriptor.label,
-            command: "pnpm",
-            args,
-            display: ["pnpm", ...args].join(" "),
-            machineVerifiable: options.machineVerifiable ?? true,
-        },
     };
 }
 export function shellCheckEnvironmentNeed(owner) {
     return {
         kind: "shellcheck-command",
         owner,
-        nextStep: {
-            id: "install-shellcheck",
-            label: "Install ShellCheck",
-            command: "sudo",
-            args: ["sh", "-c", "apt-get update && apt-get install -y shellcheck"],
-            display: "sudo apt-get update && sudo apt-get install -y shellcheck",
-            machineVerifiable: false,
-        },
     };
 }

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

@@ -2,10 +2,14 @@ import { type CiDiagnosticArtifactDeclaration } from "./ci-diagnostic-artifact.t
 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-v2.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 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?: {
@@ -17,6 +21,10 @@ export type FoundationContribution = {
     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. */
@@ -49,6 +57,10 @@ export type PackageContribution = {
     /** Requirements prepared only by a focused deployment entrypoint. */
     readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
 };
+/** 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

@@ -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}`);
+                }
+                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

@@ -23,7 +23,7 @@ overrides:
 catalog:
   "@devcontainers/cli": 0.88.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
@@ -34,28 +34,32 @@ catalog:
   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
+  execa: ^10.0.1
+  hono: ^4.13.3
   node-diff3: ^3.2.1
+  npm: 11.19.1
   oxfmt: ^0.58.0
-  oxlint: ^1.73.0
+  oxlint: ^1.77.0
   oxlint-tsgolint: ^7.0.2001
   semver: ^7.8.5
   "@types/semver": ^7.7.1
+  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: ^0.12.5
+  tailwindcss: ^4.3.3
+  tar: ^7.5.22
   telefunc: ^0.2.22
-  turbo: 2.10.5
+  turbo: 2.10.11
   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
+  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,65 @@
 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;
     };
 };
-/** 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 +69,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 +80,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 {};