@ykdz/template 0.0.13 → 0.0.15

package/node_modules/@ykdz/template-core/dist/projection-capabilities.js

@@ -5,8 +5,8 @@ import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, valid
 import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderGeneratedPnpmWorkspaceYaml, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
 import { editorCustomizationForCapabilities, loadEditorCustomizationDeclarations, } from "./editor-customization.js";
-import { playwrightBrowserAssetsEnvironmentNeed, renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
-import { packageManifestExposureFields, planPackageLinks, } from "./package-linking.js";
+import { playwrightBrowserAssetsEnvironmentNeed, renderCheckLeafCommand, renderFixCommand, renderFixLeafCommand, renderRootCheckCommand, } from "./module-graph.js";
+import { packageManifestExposureFields, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
 export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
 const strictTypescriptRootBoundary = {
     kind: "workspace-orchestration",
@@ -78,11 +78,7 @@ const capabilityInterpreters = {
             state.nodeWorkspace = capability;
             state.sourceRoot = templateSourceRootForPreset(state, sourceRootPreset(capability));
             state.operationFactories.push(workspaceNodePackagesOperations);
-            if (isRootNodeWorkspace(capability)) {
-                state.rootScriptFragments.dev = "vike dev";
-                state.rootCheckComponents.push({ kind: "build", owner: strictTypescriptRootBoundary }, { kind: "unit-test", owner: strictTypescriptRootBoundary }, { kind: "e2e-test", owner: strictTypescriptRootBoundary });
-            }
-            else if (capability.packages.length > 1) {
+            if (capability.packages.length > 1) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
             }
             const vuePackage = findVuePackage(capability);
@@ -133,13 +129,11 @@ const capabilityInterpreters = {
                 kind: "typescript-typecheck",
                 owner: strictTypescriptRootBoundary,
             });
-            if (!isRootNodeWorkspace(state.nodeWorkspace)) {
-                const workspaceBoundary = workspaceBoundaryForState(state);
-                state.rootCheckComponents.push({
-                    kind: "turbo-package-check",
-                    owner: workspaceBoundary,
-                });
-            }
+            const workspaceBoundary = workspaceBoundaryForState(state);
+            state.rootCheckComponents.push({
+                kind: "turbo-package-check",
+                owner: workspaceBoundary,
+            });
             state.packageCheckComponents.push({
                 kind: "typescript-typecheck",
                 owner: workspacePackageBoundary,
@@ -173,14 +167,10 @@ const capabilityInterpreters = {
             }, {
                 kind: "oxc-lint-fix",
                 owner: strictTypescriptRootBoundary,
-            }, ...(!isRootNodeWorkspace(state.nodeWorkspace)
-                ? [
-                    {
-                        kind: "turbo-package-fix",
-                        owner: workspaceBoundaryForState(state),
-                    },
-                ]
-                : []));
+            }, {
+                kind: "turbo-package-fix",
+                owner: workspaceBoundaryForState(state),
+            });
             state.packageFixComponents.push({ kind: "oxc-format-write", owner: workspacePackageBoundary }, { kind: "oxc-lint-fix", owner: workspacePackageBoundary });
             state.rootScriptFragments["format:check"] =
                 "oxfmt --check oxlint.config.ts oxfmt.config.ts";
@@ -468,11 +458,9 @@ function blueprintPackagesForCapabilities(capabilities, packageScope, projectNam
         }
         if (capability.kind === "workspace-node-packages") {
             return capability.packages.map((nodePackage) => {
-                const leaf = nodePackage.path === "."
-                    ? projectName
-                    : (nodePackage.path.split("/").at(-1) ?? nodePackage.path);
+                const leaf = nodePackage.path.split("/").at(-1) ?? nodePackage.path;
                 return {
-                    name: nodePackage.path === "." ? projectName : `@${packageScope}/${leaf}`,
+                    name: `@${packageScope}/${leaf}`,
                     path: nodePackage.path,
                 };
             });
@@ -790,11 +778,6 @@ function workspaceGlobBoundary(workspacePackageGlob) {
         path: workspacePackageGlob,
     };
 }
-function isRootNodeWorkspace(workspace) {
-    return (workspace?.workspacePackageGlob === "." &&
-        workspace.packages.length === 1 &&
-        workspace.packages[0]?.path === ".");
-}
 function hasVuePackage(capability) {
     return findVuePackage(capability) !== undefined;
 }
@@ -812,23 +795,102 @@ function sourceRootPreset(capability) {
     return "vue-hono-app";
 }
 function projectRootPackageScripts(checkPlan, fixPlan, fragments) {
+    const leafFragments = leafScriptFragments(fragments);
+    const directFragments = directScriptFragments(fragments);
     return {
         check: renderRootCheckCommand(checkPlan),
         fix: renderFixCommand(fixPlan),
-        ...fragments,
+        ...rootTaskEntrypoints(checkPlan, fixPlan),
+        ...directFragments,
+        ...leafFragments,
+        "check:run": noopTaskCommand(),
+        "fix:run": noopTaskCommand(),
     };
 }
 function projectPackageScripts(checkPlan, fixPlan, fragments) {
+    void checkPlan;
+    void fixPlan;
     return {
-        check: renderRootCheckCommand(checkPlan),
-        fix: renderFixCommand(fixPlan),
-        ...fragments,
+        ...directScriptFragments(fragments),
+        ...leafScriptFragments(fragments),
     };
 }
-function packageCollection(workspacePackageGlob) {
-    if (workspacePackageGlob === ".") {
-        return ".";
+const leafEntrypointNames = new Set([
+    "format:check",
+    "format:write",
+    "lint",
+    "lint:fix",
+    "typecheck",
+    "build",
+    "test",
+    "test:e2e",
+]);
+function leafScriptName(scriptName) {
+    return leafEntrypointNames.has(scriptName) ? `${scriptName}:run` : scriptName;
+}
+function leafScriptFragments(fragments) {
+    return Object.fromEntries(Object.entries(fragments)
+        .filter(([scriptName]) => leafEntrypointNames.has(scriptName))
+        .map(([scriptName, command]) => [leafScriptName(scriptName), command]));
+}
+function directScriptFragments(fragments) {
+    return Object.fromEntries(Object.entries(fragments).filter(([scriptName]) => !leafEntrypointNames.has(scriptName)));
+}
+function rootTaskEntrypoints(checkPlan, fixPlan) {
+    const taskNames = new Set([
+        ...checkPlan.components.map((component) => renderCheckLeafCommand(component).startsWith("turbo run ")
+            ? undefined
+            : leafEntrypointFromRunTask(component.kind)),
+        ...fixPlan.components.map((component) => renderFixLeafCommand(component).startsWith("turbo run ")
+            ? undefined
+            : leafEntrypointFromRunTask(component.kind)),
+    ]);
+    const entries = [];
+    for (const taskName of taskNames) {
+        if (taskName === undefined) {
+            continue;
+        }
+        entries.push([taskName, `turbo run ${taskName}:run`]);
+    }
+    return Object.fromEntries(entries);
+}
+function leafEntrypointFromRunTask(kind) {
+    switch (kind) {
+        case "oxc-format-check":
+        case "rustfmt-check":
+            return "format:check";
+        case "oxc-format-write":
+        case "rustfmt-write":
+            return "format:write";
+        case "oxc-lint":
+        case "cargo-clippy":
+            return "lint";
+        case "oxc-lint-fix":
+            return "lint:fix";
+        case "typescript-typecheck":
+            return "typecheck";
+        case "build":
+            return "build";
+        case "unit-test":
+        case "cargo-test":
+            return "test";
+        case "e2e-test":
+            return "test:e2e";
+        case "turbo-check":
+        case "turbo-package-typecheck":
+        case "turbo-package-build":
+        case "turbo-package-test":
+        case "turbo-package-e2e-test":
+        case "turbo-package-check":
+        case "turbo-fix":
+        case "turbo-package-fix":
+            return undefined;
     }
+}
+function noopTaskCommand() {
+    return 'node -e ""';
+}
+function packageCollection(workspacePackageGlob) {
     return workspacePackageGlob.slice(0, -"/*".length);
 }
 function workspacePackagePath(context, capability) {
@@ -882,9 +944,6 @@ function nodePackageName(context, nodePackage) {
     if (packageDefinition !== undefined) {
         return packageDefinition.name;
     }
-    if (nodePackage.path === ".") {
-        return context.projectName.value;
-    }
     const leaf = nodePackage.path.split("/").at(-1) ?? nodePackage.path;
     return `@${context.projectName.value}/${leaf}`;
 }
@@ -1049,6 +1108,7 @@ function vikePackageJson(context, packageName, scripts) {
             oxlint: "catalog:",
             "oxlint-tsgolint": "catalog:",
             tailwindcss: "catalog:",
+            turbo: "catalog:",
             typescript: "catalog:",
             vite: "catalog:",
             vitest: "catalog:",
@@ -1131,17 +1191,25 @@ function rustRootPackageJson(context, packageScripts, state) {
         packageManager: context.toolchain.packageManagerPin.value,
     };
 }
-function rustWorkspacePackageJson(context, scripts) {
+function rustWorkspacePackageJson(context) {
     return {
         name: rustWorkspacePackageName(context),
         version: "0.0.0",
         private: true,
-        scripts,
+        scripts: rustWorkspacePackageScripts(),
         engines: {
             node: context.toolchain.nodeLtsMajor.value,
         },
     };
 }
+function rustWorkspacePackageScripts() {
+    return {
+        "format:check:run": "cargo fmt --all -- --check",
+        "format:write:run": "cargo fmt --all",
+        "lint:run": "cargo clippy --workspace --all-targets -- -D warnings",
+        "test:run": "cargo test --workspace",
+    };
+}
 function workspaceLibraryPackageOperations({ context, state, packageScripts, packageScriptsByPath, }) {
     if (state.package === undefined) {
         throw new Error("workspace-library-package capability state is missing");
@@ -1177,14 +1245,7 @@ function workspaceLibraryPackageOperations({ context, state, packageScripts, pac
             to: "turbo.json",
             value: {
                 tasks: {
-                    build: packageLinkPlan.turboTasks.build,
-                    check: packageLinkPlan.turboTasks.check,
-                    typecheck: packageLinkPlan.turboTasks.typecheck,
-                    test: packageLinkPlan.turboTasks.test,
-                    "test:e2e": packageLinkPlan.turboTasks["test:e2e"],
-                    fix: {
-                        cache: false,
-                    },
+                    ...packageLinkPlan.turboTasks,
                 },
             },
         },
@@ -1223,18 +1284,14 @@ function workspaceLibraryPackageOperations({ context, state, packageScripts, pac
         },
     ];
 }
-function rustBinaryWorkspaceOperations({ context, state, packageScripts, packageScriptsByPath, }) {
+function rustBinaryWorkspaceOperations({ context, state, packageScripts, }) {
     if (state.rustWorkspace === undefined) {
         throw new Error("rust-binary-workspace capability state is missing");
     }
     const capability = state.rustWorkspace;
     const packagePath = rustWorkspacePackagePath(context);
-    const workspacePackageScripts = packageScriptsByPath.get(capability.workspacePackageGlob);
-    if (workspacePackageScripts === undefined) {
-        throw new Error(`Missing package scripts for ${capability.workspacePackageGlob}`);
-    }
     const rootManifest = rustRootPackageJson(context, packageScripts, state);
-    const packageManifest = rustWorkspacePackageJson(context, workspacePackageScripts);
+    const packageManifest = rustWorkspacePackageJson(context);
     const rustLayer = rustToolLayer();
     const dockerfileFragments = readDevelopmentContainerDockerfileFragments(state, ["rust"]);
     const editorCustomization = editorCustomizationForCapabilities(state.editorCustomizationCapabilities, editorCustomizationDeclarationsForState(state));
@@ -1270,12 +1327,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
             kind: "writeJson",
             to: "turbo.json",
             value: {
-                tasks: {
-                    check: {},
-                    fix: {
-                        cache: false,
-                    },
-                },
+                tasks: packageTurboTasks({ dependencyBuildsRequired: false }),
             },
         },
         {
@@ -1338,6 +1390,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
             value: developmentContainer.devcontainer,
+            multilineArrays: ["customizations.vscode.extensions"],
         },
         {
             ...developmentContainer.dockerfileOperation,
@@ -1389,9 +1442,7 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
         }
         return vuePackageJson(context, packageName, scripts, packageLinkPlan.manifestDependenciesByPackagePath.get(nodePackage.path));
     });
-    const rootManifest = isRootNodeWorkspace(capability)
-        ? packageManifests[0]
-        : rootPackageJson(context, packageScripts, state);
+    const rootManifest = rootPackageJson(context, packageScripts, state);
     if (rootManifest === undefined) {
         throw new Error("workspace-node-packages rendered no package manifests");
     }
@@ -1429,11 +1480,7 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
             to: "turbo.json",
             value: {
                 tasks: {
-                    build: packageLinkPlan.turboTasks.build,
-                    check: packageLinkPlan.turboTasks.check,
-                    typecheck: packageLinkPlan.turboTasks.typecheck,
-                    test: packageLinkPlan.turboTasks.test,
-                    "test:e2e": packageLinkPlan.turboTasks["test:e2e"],
+                    ...packageLinkPlan.turboTasks,
                     ...(hasVuePackage(capability)
                         ? {
                             dev: {
@@ -1442,9 +1489,6 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
                             },
                         }
                         : {}),
-                    fix: {
-                        cache: false,
-                    },
                 },
             },
         },
@@ -1454,15 +1498,11 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
             text: gitignoreForNodeWorkspace(capability),
         },
         ...capability.packages.flatMap((nodePackage, index) => [
-            ...(nodePackage.path === "."
-                ? []
-                : [
-                    {
-                        kind: "writeJson",
-                        to: `${nodePackage.path}/package.json`,
-                        value: packageManifests[index],
-                    },
-                ]),
+            {
+                kind: "writeJson",
+                to: `${nodePackage.path}/package.json`,
+                value: packageManifests[index],
+            },
             ...nodePackageTsconfigOperations(nodePackage, capability),
             ...nodePackage.sourceFiles.map((sourceFile) => ({
                 kind: "copyFile",
@@ -1491,99 +1531,43 @@ function nodePackageScripts(nodePackage, workspace) {
         "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix",
     };
     if (nodePackage.kind === "hono-api") {
-        const checks = {
-            components: [
-                { kind: "oxc-format-check", owner: workspacePackageBoundary },
-                { kind: "oxc-lint", owner: workspacePackageBoundary },
-                { kind: "typescript-typecheck", owner: workspacePackageBoundary },
-                { kind: "build", owner: workspacePackageBoundary },
-                { kind: "unit-test", owner: workspacePackageBoundary },
-            ],
-            environmentNeeds: [],
-        };
-        const fixes = {
-            components: [
-                { kind: "oxc-format-write", owner: workspacePackageBoundary },
-                { kind: "oxc-lint-fix", owner: workspacePackageBoundary },
-            ],
-        };
         return {
-            build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-            check: renderRootCheckCommand(checks),
+            "build:run": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
             ...(workspace.packages.length > 1
                 ? { dev: "tsx watch src/server.ts" }
                 : {}),
-            fix: renderFixCommand(fixes),
-            ...oxcScripts,
+            ...leafScriptFragments(oxcScripts),
             start: "node dist/server.js",
-            test: "vitest run",
-            typecheck: "tsc -p tsconfig.json --noEmit",
+            "test:run": "vitest run",
+            "typecheck:run": "tsc -p tsconfig.json --noEmit",
         };
     }
     if (nodePackage.kind === "vike-app") {
-        const checks = {
-            components: [
-                { kind: "oxc-format-check", owner: workspacePackageBoundary },
-                { kind: "oxc-lint", owner: workspacePackageBoundary },
-                { kind: "typescript-typecheck", owner: workspacePackageBoundary },
-                { kind: "build", owner: workspacePackageBoundary },
-                { kind: "unit-test", owner: workspacePackageBoundary },
-                { kind: "e2e-test", owner: workspacePackageBoundary },
-            ],
-            environmentNeeds: [],
-        };
-        const fixes = {
-            components: [
-                { kind: "oxc-format-write", owner: workspacePackageBoundary },
-                { kind: "oxc-lint-fix", owner: workspacePackageBoundary },
-            ],
-        };
         return {
-            build: "vike build",
-            check: renderRootCheckCommand(checks),
+            "build:run": "vike build",
             dev: "vike dev",
             "drizzle:generate": "drizzle-kit generate",
             "drizzle:migrate": "drizzle-kit migrate",
             "drizzle:studio": "drizzle-kit studio",
-            fix: renderFixCommand(fixes),
-            "format:check": "oxfmt --check --config oxfmt.config.ts .",
-            "format:write": "oxfmt --write --config oxfmt.config.ts .",
-            lint: "oxlint --type-aware --config oxlint.config.ts .",
-            "lint:fix": "oxlint --type-aware --config oxlint.config.ts . --fix",
+            "format:check:run": "oxfmt --check --config ../../oxfmt.config.ts .",
+            "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
+            "lint:run": "oxlint --type-aware --config ../../oxlint.config.ts .",
+            "lint:fix:run": "oxlint --type-aware --config ../../oxlint.config.ts . --fix",
             preview: "vike preview",
             start: "node ./dist/server/index.mjs",
-            test: "vitest run",
-            "test:e2e": "playwright test --config playwright.config.ts",
-            typecheck: "vue-tsc --build --noEmit",
+            "test:run": "vitest run",
+            "test:e2e:run": "playwright test --config playwright.config.ts",
+            "typecheck:run": "vue-tsc --build --noEmit",
         };
     }
-    const checks = {
-        components: [
-            { kind: "oxc-format-check", owner: workspacePackageBoundary },
-            { kind: "oxc-lint", owner: workspacePackageBoundary },
-            { kind: "typescript-typecheck", owner: workspacePackageBoundary },
-            { kind: "build", owner: workspacePackageBoundary },
-            { kind: "unit-test", owner: workspacePackageBoundary },
-            { kind: "e2e-test", owner: workspacePackageBoundary },
-        ],
-        environmentNeeds: [],
-    };
-    const fixes = {
-        components: [
-            { kind: "oxc-format-write", owner: workspacePackageBoundary },
-            { kind: "oxc-lint-fix", owner: workspacePackageBoundary },
-        ],
-    };
     return {
-        build: "vite build",
-        check: renderRootCheckCommand(checks),
+        "build:run": "vite build",
         dev: "vite",
-        fix: renderFixCommand(fixes),
-        ...oxcScripts,
+        ...leafScriptFragments(oxcScripts),
         preview: "vite preview",
-        test: "vitest run",
-        "test:e2e": "pnpm run build && node --experimental-strip-types scripts/run-playwright.ts",
-        typecheck: workspace.packages.length > 1
+        "test:run": "vitest run",
+        "test:e2e:run": "node --experimental-strip-types scripts/run-playwright.ts",
+        "typecheck:run": workspace.packages.length > 1
             ? "vue-tsc --build"
             : "vue-tsc --build --noEmit",
     };
@@ -1593,7 +1577,19 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
         return [
             {
                 kind: "writeJson",
-                to: "tsconfig.app.json",
+                to: `${nodePackage.path}/tsconfig.json`,
+                value: {
+                    files: [],
+                    references: [
+                        { path: "./tsconfig.app.json" },
+                        { path: "./tsconfig.test.json" },
+                        { path: "./tsconfig.node.json" },
+                    ],
+                },
+            },
+            {
+                kind: "writeJson",
+                to: `${nodePackage.path}/tsconfig.app.json`,
                 value: {
                     extends: "@vue/tsconfig/tsconfig.dom.json",
                     compilerOptions: {
@@ -1612,17 +1608,16 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                         "assets/**/*.svg",
                         "components/**/*.vue",
                         "database/**/*.ts",
-                        "env.d.ts",
-                        "global.d.ts",
                         "pages/**/*.ts",
                         "pages/**/*.vue",
                         "server/**/*.ts",
+                        "types/**/*.d.ts",
                     ],
                 },
             },
             {
                 kind: "writeJson",
-                to: "tsconfig.test.json",
+                to: `${nodePackage.path}/tsconfig.test.json`,
                 value: {
                     extends: "./tsconfig.app.json",
                     compilerOptions: {
@@ -1637,7 +1632,7 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
             },
             {
                 kind: "writeJson",
-                to: "tsconfig.node.json",
+                to: `${nodePackage.path}/tsconfig.node.json`,
                 multilineArrays: ["include"],
                 value: {
                     compilerOptions: {
@@ -1813,9 +1808,6 @@ function sourcePathWithinNodePackage(sourceFile, workspace) {
 }
 function nodePackageTargetPath(nodePackage, sourceFile, workspace) {
     const packageRelativePath = sourcePathWithinNodePackage(sourceFile, workspace);
-    if (nodePackage.path === ".") {
-        return packageRelativePath;
-    }
     return `${nodePackage.path}/${packageRelativePath}`;
 }
 function gitignoreForNodeWorkspace(workspace) {
@@ -1900,9 +1892,9 @@ function rootTsconfigReferences(workspace) {
         }
         if (nodePackage.kind === "vike-app") {
             return [
-                { path: "./tsconfig.app.json" },
-                { path: "./tsconfig.test.json" },
-                { path: "./tsconfig.node.json" },
+                { path: `./${nodePackage.path}/tsconfig.app.json` },
+                { path: `./${nodePackage.path}/tsconfig.test.json` },
+                { path: `./${nodePackage.path}/tsconfig.node.json` },
             ];
         }
         return [
@@ -1966,6 +1958,7 @@ function nodePnpmDevcontainerOperations({ context, state, }) {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
             value: developmentContainer.devcontainer,
+            multilineArrays: ["customizations.vscode.extensions"],
         },
         {
             ...developmentContainer.dockerfileOperation,

package/node_modules/@ykdz/template-shared/dist/index.d.ts

@@ -78,7 +78,7 @@ export type WorkspaceLibraryPackageCapabilityDeclaration = {
     readonly sourceFiles: readonly string[];
 };
 export type WorkspaceNodePackageKind = "hono-api" | "vike-app" | "vue-app";
-export type WorkspaceNodePackagePath = "." | "apps/api" | "apps/web";
+export type WorkspaceNodePackagePath = "apps/api" | "apps/web";
 export type WorkspaceNodePackageDeclaration = {
     readonly kind: WorkspaceNodePackageKind;
     readonly path: WorkspaceNodePackagePath;
@@ -86,7 +86,7 @@ export type WorkspaceNodePackageDeclaration = {
 };
 export type WorkspaceNodePackagesCapabilityDeclaration = {
     readonly kind: "workspace-node-packages";
-    readonly workspacePackageGlob: "." | "apps/*";
+    readonly workspacePackageGlob: "apps/*";
     readonly packages: readonly WorkspaceNodePackageDeclaration[];
     readonly packageLinks?: readonly {
         readonly consumerPackagePath: "apps/web";
@@ -404,7 +404,7 @@ export declare const presetSourceManifestJsonSchema: {
                                                 readonly const: "workspace-node-packages";
                                             };
                                             readonly workspacePackageGlob: {
-                                                readonly enum: readonly [".", "apps/*"];
+                                                readonly const: "apps/*";
                                             };
                                             readonly packages: {
                                                 readonly type: "array";
@@ -418,7 +418,7 @@ export declare const presetSourceManifestJsonSchema: {
                                                             readonly enum: readonly ["hono-api", "vike-app", "vue-app"];
                                                         };
                                                         readonly path: {
-                                                            readonly enum: readonly [".", "apps/api", "apps/web"];
+                                                            readonly enum: readonly ["apps/api", "apps/web"];
                                                         };
                                                         readonly sourceFiles: {
                                                             readonly type: "array";

package/node_modules/@ykdz/template-shared/dist/index.js

@@ -235,7 +235,7 @@ export const presetSourceManifestJsonSchema = {
                                             required: ["kind", "workspacePackageGlob", "packages"],
                                             properties: {
                                                 kind: { const: "workspace-node-packages" },
-                                                workspacePackageGlob: { enum: [".", "apps/*"] },
+                                                workspacePackageGlob: { const: "apps/*" },
                                                 packages: {
                                                     type: "array",
                                                     minItems: 1,
@@ -247,7 +247,7 @@ export const presetSourceManifestJsonSchema = {
                                                             kind: {
                                                                 enum: ["hono-api", "vike-app", "vue-app"],
                                                             },
-                                                            path: { enum: [".", "apps/api", "apps/web"] },
+                                                            path: { enum: ["apps/api", "apps/web"] },
                                                             sourceFiles: {
                                                                 type: "array",
                                                                 minItems: 1,
@@ -849,11 +849,7 @@ const workspaceNodePackageKindSet = new Set([
     "vike-app",
     "vue-app",
 ]);
-const workspaceNodePackagePathSet = new Set([
-    ".",
-    "apps/api",
-    "apps/web",
-]);
+const workspaceNodePackagePathSet = new Set(["apps/api", "apps/web"]);
 function isProjectionCapabilityKind(value) {
     return projectionCapabilityKindSet.has(value);
 }
@@ -979,7 +975,7 @@ function parseWorkspaceNodePackage(value, pathPrefix) {
     if (packagePath === undefined) {
         issues.push({
             path: `${pathPrefix}.path`,
-            message: "workspace-node-packages package path must be ., apps/api, or apps/web",
+            message: "workspace-node-packages package path must be apps/api or apps/web",
         });
     }
     if (!Array.isArray(value.sourceFiles)) {
@@ -1083,14 +1079,13 @@ function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths,
 }
 function parseWorkspaceNodePackagesCapability(capability, pathPrefix) {
     const issues = [];
-    const workspacePackageGlob = capability.workspacePackageGlob === "." ||
-        capability.workspacePackageGlob === "apps/*"
+    const workspacePackageGlob = capability.workspacePackageGlob === "apps/*"
         ? capability.workspacePackageGlob
         : undefined;
     if (workspacePackageGlob === undefined) {
         issues.push({
             path: `${pathPrefix}.workspacePackageGlob`,
-            message: "workspace-node-packages currently supports workspacePackageGlob: . or apps/*",
+            message: "workspace-node-packages currently supports workspacePackageGlob: apps/*",
         });
     }
     if (!Array.isArray(capability.packages) || capability.packages.length === 0) {
@@ -1591,6 +1586,17 @@ function normalizeProjectBlueprint(blueprint) {
             }),
     };
 }
+function packagePathIssue(packagePath, path) {
+    const segments = packagePath.split("/");
+    if (segments.length !== 2 ||
+        segments.some((segment) => segment.length === 0 || segment === ".")) {
+        return {
+            path,
+            message: "Package Path must be exactly two non-root path segments, such as apps/web or packages/ui",
+        };
+    }
+    return undefined;
+}
 export function validateProjectBlueprint(input, options = {}) {
     const result = v.safeParse(projectBlueprintSchema, input);
     if (!result.success) {
@@ -1646,7 +1652,10 @@ export function validateProjectBlueprint(input, options = {}) {
         }
     }
     if (blueprint.packages) {
-        semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"));
+        semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"), ...blueprint.packages.flatMap((projectPackage, index) => {
+            const issue = packagePathIssue(projectPackage.path, `$.packages[${index}].path`);
+            return issue === undefined ? [] : [issue];
+        }));
     }
     if (semanticIssues.length > 0) {
         return { ok: false, issues: semanticIssues };