@ykdz/template 0.0.35 → 0.0.37

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/src/api.ts

@@ -1,7 +1,5 @@
-const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ?? "/";
-
 export async function getHealth(): Promise<{ status: "ok" }> {
-  const response = await fetch(`${apiBaseUrl.replace(/\/$/, "")}/api/health`);
+  const response = await fetch("/api/health");
 
   if (!response.ok) {
     throw new Error(`Health check failed with ${response.status}`);

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/turbo.json

@@ -4,10 +4,6 @@
   "tasks": {
     "build": {
       "outputs": ["dist/**"]
-    },
-    "test:e2e": {
-      "dependsOn": ["build"],
-      "cache": false
     }
   }
 }

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/vite.config.ts

@@ -8,6 +8,7 @@ export default defineConfig(({ mode }) => {
     process.env.VITE_API_BASE_URL ??
     env.VITE_API_BASE_URL ??
     "http://localhost:3000";
+  const previewPort = process.env.PLAYWRIGHT_WEB_PORT;
 
   return {
     plugins: [vue(), tailwindcss()],
@@ -17,6 +18,7 @@ export default defineConfig(({ mode }) => {
       },
     },
     preview: {
+      ...(previewPort === undefined ? {} : { port: Number(previewPort) }),
       proxy: {
         "/api": apiBaseUrl,
       },

package/node_modules/@ykdz/template-core/dist/ci-diagnostic-artifact.d.ts

@@ -1,8 +1,8 @@
-import type { PackageBoundaryOwner } from "./module-graph.ts";
+import type { ComponentOwner } from "./module-graph.ts";
 /** Closed, owner-scoped native evidence a Package Contribution may retain in CI. */
 export type CiDiagnosticArtifactDeclaration = {
     readonly kind: "playwright";
-    readonly owner: PackageBoundaryOwner;
+    readonly owner: ComponentOwner;
 };
 /**
  * Validates the intentionally closed diagnostic declaration surface.  It does

package/node_modules/@ykdz/template-core/dist/ci-diagnostic-artifact.js

@@ -34,14 +34,18 @@ export function assertCiDiagnosticArtifactDeclaration(value) {
     if (!isRecord(value.owner) || !hasExactKeys(value.owner, ["kind", "path"])) {
         throw new Error("CI Diagnostic Artifact requires a Package Boundary owner");
     }
-    if (value.owner.kind !== "package-boundary" ||
-        typeof value.owner.path !== "string" ||
-        !isSafePackagePath(value.owner.path)) {
+    if ((value.owner.kind !== "workspace-orchestration" ||
+        value.owner.path !== ".") &&
+        (value.owner.kind !== "package-boundary" ||
+            typeof value.owner.path !== "string" ||
+            !isSafePackagePath(value.owner.path))) {
         throw new Error("CI Diagnostic Artifact owner has an unsafe Package Boundary path");
     }
     return {
         kind: "playwright",
-        owner: { kind: "package-boundary", path: value.owner.path },
+        owner: value.owner.kind === "workspace-orchestration"
+            ? { kind: "workspace-orchestration", path: "." }
+            : { kind: "package-boundary", path: value.owner.path },
     };
 }
 /**
@@ -58,7 +62,8 @@ export function composeCiDiagnosticArtifacts(options) {
     const artifacts = new Map();
     for (const value of options.declarations) {
         const declaration = assertCiDiagnosticArtifactDeclaration(value);
-        if (!owners.has(declaration.owner.path)) {
+        if (declaration.owner.kind === "package-boundary" &&
+            !owners.has(declaration.owner.path)) {
             throw new Error(`CI Diagnostic Artifact owner is not a declared Package Boundary: ${declaration.owner.path}`);
         }
         const key = `${declaration.kind}:${declaration.owner.path}`;

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

@@ -11,90 +11,52 @@ export type PlaywrightBrowserAssetsEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";
     readonly browser: "chromium";
     readonly owner: ComponentOwner;
-    readonly nextStep: {
-        readonly id: string;
-        readonly label: string;
-        readonly command: string;
-        readonly args: readonly string[];
-        readonly display: string;
-        readonly machineVerifiable: boolean;
-    };
 };
 export type ShellCheckEnvironmentNeed = {
     readonly kind: "shellcheck-command";
     readonly owner: ComponentOwner;
-    readonly nextStep: {
-        readonly id: "install-shellcheck";
-        readonly label: "Install ShellCheck";
-        readonly command: "sudo";
-        readonly args: readonly string[];
-        readonly display: "sudo apt-get update && sudo apt-get install -y shellcheck";
-        readonly machineVerifiable: false;
-    };
 };
 /** Rust task leaves require the maintained toolchain in local and CI plans. */
 export type RustToolchainEnvironmentNeed = {
     readonly kind: "rust-toolchain";
     readonly owner: ComponentOwner;
     readonly toolchain: "stable";
-    readonly nextStep: {
-        readonly id: "install-rust-toolchain";
-        readonly label: "Install Rust toolchain";
-        readonly command: "rustup";
-        readonly args: readonly string[];
-        readonly display: "rustup toolchain install stable --component rustfmt --component clippy";
-        readonly machineVerifiable: boolean;
-    };
 };
 /**
  * Docker is needed only by the focused deployment mode. It is deliberately
- * outside ordinary Check Environment Needs, whose preparation and next steps
- * apply to every generated-check scenario.
+ * outside ordinary Check Environment Needs, which apply to every
+ * generated-check scenario.
  */
 export type DockerEngineEnvironmentNeed = {
     readonly kind: "docker-engine";
-    readonly preparation: {
-        readonly id: "verify-docker-engine";
-        readonly label: "Verify Docker engine";
-        readonly command: "docker";
-        readonly args: readonly ["version", "--format", "{{.Server.Version}}"];
-        readonly display: "docker version --format {{.Server.Version}}";
-        readonly machineVerifiable: true;
-    };
 };
 export type CheckEnvironmentNeed = PlaywrightBrowserAssetsEnvironmentNeed | ShellCheckEnvironmentNeed | RustToolchainEnvironmentNeed;
 export type DeploymentEnvironmentNeed = DockerEngineEnvironmentNeed;
-/**
- * The durable form of a Check Environment Need. It deliberately retains only
- * the explicit preparation fact, never a task name or package execution list.
- */
-export type CheckEnvironmentNeedFact = Pick<PlaywrightBrowserAssetsEnvironmentNeed, "kind" | "browser" | "owner"> | Pick<ShellCheckEnvironmentNeed, "kind" | "owner"> | Pick<RustToolchainEnvironmentNeed, "kind" | "owner" | "toolchain">;
-/** Deployment preparation is likewise durable without selecting an executing package. */
-export type DeploymentEnvironmentNeedFact = Pick<DockerEngineEnvironmentNeed, "kind">;
-export declare function checkEnvironmentNeedFact(need: CheckEnvironmentNeed): CheckEnvironmentNeedFact;
-export declare function checkEnvironmentNeedFromFact(fact: CheckEnvironmentNeedFact): CheckEnvironmentNeed;
-export declare function deploymentEnvironmentNeedFact(need: DeploymentEnvironmentNeed): DeploymentEnvironmentNeedFact;
-export declare function deploymentEnvironmentNeedFromFact(fact: DeploymentEnvironmentNeedFact): DeploymentEnvironmentNeed;
+export type EnvironmentNeedsMetadata = {
+    readonly schemaVersion: 1;
+    readonly check: readonly CheckEnvironmentNeed[];
+    readonly deployment: readonly DeploymentEnvironmentNeed[];
+};
+/** Validates, deduplicates, and canonically orders durable Environment Needs. */
+export declare function normalizeEnvironmentNeeds(options: {
+    readonly check: readonly CheckEnvironmentNeed[];
+    readonly deployment: readonly DeploymentEnvironmentNeed[];
+}): EnvironmentNeedsMetadata;
+/** Strict codec for Local Template Metadata consumed by Package Addition. */
+export declare function parseEnvironmentNeedsMetadata(value: unknown): EnvironmentNeedsMetadata;
 export declare function rustToolchainEnvironmentNeed(owner: ComponentOwner): RustToolchainEnvironmentNeed;
 export declare function dockerEngineEnvironmentNeed(): DockerEngineEnvironmentNeed;
-export declare const qualityTaskVocabulary: readonly ["boundaries", "format:check", "lint", "typecheck", "build", "test", "test:e2e"];
+export declare const qualityTaskVocabulary: readonly ["format:check", "lint", "typecheck", "build", "test", "test:e2e"];
 export declare function renderTurboRunCommand(taskNames: readonly string[], args?: readonly string[], options?: {
     readonly outputLogs?: "errors-only" | "full";
     readonly continueAfterFailure?: boolean;
     readonly taskPrefix?: boolean;
 }): string;
-export declare function renderRootCheckCommand(): string;
+export declare function renderRootCheckCommand(additionalTasks?: readonly string[]): string;
 export declare function renderDeploymentCheckCommand(): string;
 export declare function renderFixCommand(): string;
-export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed, options?: {
-    readonly withDeps?: boolean;
-}): string;
-export declare function playwrightBrowserAssetsNextStepDescriptor(owner: ComponentOwner): Pick<CheckEnvironmentNeed["nextStep"], "id" | "label">;
 export declare function playwrightBrowserAssetsEnvironmentNeed(options: {
     readonly browser: "chromium";
     readonly owner: ComponentOwner;
-    readonly id?: string;
-    readonly label?: string;
-    readonly machineVerifiable?: boolean;
 }): PlaywrightBrowserAssetsEnvironmentNeed;
 export declare function shellCheckEnvironmentNeed(owner: ComponentOwner): ShellCheckEnvironmentNeed;

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

@@ -1,77 +1,158 @@
-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`);
     }
-    return dockerEngineEnvironmentNeed();
+    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 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",
     "format:check",
     "lint",
     "typecheck",
@@ -92,11 +173,14 @@ export function renderTurboRunCommand(taskNames, args = [], options = {}) {
         ...(options.taskPrefix ? ["--log-prefix=task"] : []),
     ].join(" ");
 }
-export function renderRootCheckCommand() {
-    return renderTurboRunCommand(qualityTaskVocabulary, [], {
-        continueAfterFailure: true,
-        taskPrefix: true,
-    });
+export function renderRootCheckCommand(additionalTasks = []) {
+    return [
+        "pnpm run boundaries",
+        renderTurboRunCommand([...qualityTaskVocabulary, ...additionalTasks], [], {
+            continueAfterFailure: true,
+            taskPrefix: true,
+        }),
+    ].join(" && ");
 }
 export function renderDeploymentCheckCommand() {
     return renderTurboRunCommand(["deployment"], [], { taskPrefix: true });
@@ -108,65 +192,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,35 +2,69 @@ 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 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;
+            readonly dockerClientToolLayer: 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;
-    /** Source-backed coordinated files projected by Foundation. */
-    readonly templateFiles?: readonly {
-        readonly identity: string;
-        readonly source: TemplateSourceHandle;
-        readonly from: string;
-        readonly to: string;
-        readonly replacements?: Readonly<Record<string, string>> | undefined;
-    }[] | undefined;
+};
+export type FoundationTemplateAssetSource = {
+    readonly source: TemplateSourceHandle;
+    readonly from: string;
 };
 /** A preset-agnostic package-sized part of a Generated Repository Plan. */
 export type PackageContribution = {
@@ -46,9 +80,11 @@ export type PackageContribution = {
     readonly environmentNeeds: readonly CheckEnvironmentNeed[];
     /** Closed native CI evidence owned by this Package Boundary. */
     readonly ciDiagnosticArtifacts?: readonly CiDiagnosticArtifactDeclaration[];
-    /** 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;