@ykdz/template 0.0.12 → 0.0.13

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/server/app.ts

@@ -0,0 +1,25 @@
+import vike from "@vikejs/hono";
+import { Hono } from "hono";
+import { Telefunc } from "telefunc/node";
+
+import { createDatabase } from "#/database/db";
+import { api } from "#/server/api";
+
+const telefunc = new Telefunc();
+
+export const app = new Hono();
+
+app.route("/api", api);
+
+app.all("/_telefunc", async (c) => {
+  const response = await telefunc.serve({
+    request: c.req.raw,
+    context: {
+      db: createDatabase(),
+    },
+  });
+
+  return response ?? c.notFound();
+});
+
+vike(app);

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/test/e2e/app.spec.ts

@@ -0,0 +1,10 @@
+import { expect, test } from "@playwright/test";
+
+test("renders the Vike home page", async ({ page }) => {
+  await page.goto("/");
+  await expect(
+    page.getByRole("heading", { name: "Full-stack Vike app" }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Count 0" }).click();
+  await expect(page.getByRole("button", { name: "Count 1" })).toBeVisible();
+});

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/test/todos.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+
+import { createDatabase } from "#/database/db";
+import { createTodo, listTodos } from "#/database/queries/todos";
+
+describe("todo queries", () => {
+  it("creates and lists todos through Drizzle SQLite", async () => {
+    const db = createDatabase(":memory:");
+
+    db.run(
+      "CREATE TABLE todos (id integer PRIMARY KEY AUTOINCREMENT NOT NULL, title text NOT NULL, completed integer DEFAULT false NOT NULL, created_at text DEFAULT (CURRENT_TIMESTAMP) NOT NULL)",
+    );
+
+    await expect(createTodo(db, { title: "Ship" })).resolves.toMatchObject({
+      id: 1,
+      title: "Ship",
+    });
+    await expect(listTodos(db)).resolves.toMatchObject([{ title: "Ship" }]);
+  });
+});

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/vite.config.ts

@@ -0,0 +1,12 @@
+import tailwindcss from "@tailwindcss/vite";
+import vue from "@vitejs/plugin-vue";
+import telefunc from "telefunc/vite";
+import vike from "vike/plugin";
+import { defineConfig, type PluginOption } from "vite";
+
+// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- telefunc/vite currently types its plugin factory as any.
+const telefuncPlugin = telefunc() as PluginOption;
+
+export default defineConfig({
+  plugins: [vike(), telefuncPlugin, vue(), tailwindcss()],
+});

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ["test/**/*.test.ts"],
+  },
+});

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

@@ -1,7 +1,4 @@
-// @template-anchor api-type-import-start
-import type { AppType } from "__API_PACKAGE__";
-import { hc } from "hono/client";
-// @template-anchor api-type-import-end
+// @template-anchor api-type-imports
 
 const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ?? "/";
 

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

@@ -396,7 +396,8 @@ function workspacePackageGlobsFromBlueprint(blueprint) {
 }
 function turboPackageTaskCommand(task, workspacePackageGlobs) {
     const filters = workspacePackageGlobs.map((glob) => `--filter './${glob}'`);
-    return [`turbo run ${task}`, ...filters].join(" ");
+    const concurrency = task === "check" ? ["--concurrency=1"] : [];
+    return [`turbo run ${task}`, ...concurrency, ...filters].join(" ");
 }
 function rootScriptWithTurboPackageTask(script, task, workspacePackageGlobs) {
     const commands = script.split(" && ");

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

@@ -10,7 +10,10 @@ catalog:
   "@types/node": ^24.0.0
   "@types/web-bluetooth": ^0.0.21
   "@vitejs/plugin-vue": ^6.0.7
+  "@vikejs/hono": ^0.2.1
   "@vue/tsconfig": ^0.9.1
+  drizzle-kit: 1.0.0-beta.22
+  drizzle-orm: 1.0.0-beta.22
   execa: ^9.6.1
   hono: ^4.12.27
   oxfmt: ^0.57.0
@@ -18,12 +21,15 @@ catalog:
   oxlint-tsgolint: ^0.24.0
   pinia: ^3.0.4
   tailwindcss: ^4.3.2
+  telefunc: ^0.2.21
   tsc-alias: ^1.8.17
   tsx: ^4.22.4
   turbo: 2.10.2
   typescript: ^6.0.3
   valibot: ^1.4.2
   vite: ^8.1.2
+  vike: ^0.4.260
+  vike-vue: ^0.9.12
   vitest: ^4.1.9
   vue: ^3.5.39
   vue-tsc: ^3.3.6

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

@@ -5,7 +5,7 @@ import type { PresetBlueprintOptions, PresetPackageAdditionOptions, PresetPackag
 import type { PresetSourceManifestPreset } from "./preset-source.js";
 export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
 export type { GithubMaintenanceCapabilityDeclaration, NodePnpmDevcontainerCapabilityDeclaration, OxcFormatLintCapabilityDeclaration, PresetProjectionDeclaration, ProjectionCapabilityDeclaration, ProjectionCapabilityKind, RustBinaryWorkspaceCapabilityDeclaration, StrictTypescriptRootCapabilityDeclaration, WorkspaceLibraryPackageCapabilityDeclaration, WorkspaceNodePackageDeclaration, WorkspaceNodePackageKind, WorkspaceNodePackagesCapabilityDeclaration, WorkspaceNodePackagePath, };
-export type ProjectionSourcePreset = "hono-api" | "rust-bin" | "ts-lib" | "vue-app" | "vue-hono-app";
+export type ProjectionSourcePreset = "hono-api" | "rust-bin" | "ts-lib" | "vike-app" | "vue-app" | "vue-hono-app";
 export type PresetProjectionSourceRoots = {
     readonly preset: (sourcePreset: ProjectionSourcePreset) => string;
     readonly sharedOxc: () => string;

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

@@ -78,7 +78,11 @@ const capabilityInterpreters = {
             state.nodeWorkspace = capability;
             state.sourceRoot = templateSourceRootForPreset(state, sourceRootPreset(capability));
             state.operationFactories.push(workspaceNodePackagesOperations);
-            if (capability.packages.length > 1) {
+            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) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
             }
             const vuePackage = findVuePackage(capability);
@@ -129,11 +133,13 @@ const capabilityInterpreters = {
                 kind: "typescript-typecheck",
                 owner: strictTypescriptRootBoundary,
             });
-            const workspaceBoundary = workspaceBoundaryForState(state);
-            state.rootCheckComponents.push({
-                kind: "turbo-package-check",
-                owner: workspaceBoundary,
-            });
+            if (!isRootNodeWorkspace(state.nodeWorkspace)) {
+                const workspaceBoundary = workspaceBoundaryForState(state);
+                state.rootCheckComponents.push({
+                    kind: "turbo-package-check",
+                    owner: workspaceBoundary,
+                });
+            }
             state.packageCheckComponents.push({
                 kind: "typescript-typecheck",
                 owner: workspacePackageBoundary,
@@ -167,10 +173,14 @@ const capabilityInterpreters = {
             }, {
                 kind: "oxc-lint-fix",
                 owner: strictTypescriptRootBoundary,
-            }, {
-                kind: "turbo-package-fix",
-                owner: workspaceBoundaryForState(state),
-            });
+            }, ...(!isRootNodeWorkspace(state.nodeWorkspace)
+                ? [
+                    {
+                        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";
@@ -458,9 +468,11 @@ function blueprintPackagesForCapabilities(capabilities, packageScope, projectNam
         }
         if (capability.kind === "workspace-node-packages") {
             return capability.packages.map((nodePackage) => {
-                const leaf = nodePackage.path.split("/").at(-1) ?? nodePackage.path;
+                const leaf = nodePackage.path === "."
+                    ? projectName
+                    : (nodePackage.path.split("/").at(-1) ?? nodePackage.path);
                 return {
-                    name: `@${packageScope}/${leaf}`,
+                    name: nodePackage.path === "." ? projectName : `@${packageScope}/${leaf}`,
                     path: nodePackage.path,
                 };
             });
@@ -539,6 +551,8 @@ function packageAdditionOperationsForCapability(options) {
             return libraryPackageAdditionOperations(options);
         case "hono-api":
             return honoApiPackageAdditionOperations(options);
+        case "vike-app":
+            throw new Error("vike-app cannot be used for Package Addition");
         case "vue-app":
             return vueAppPackageAdditionOperations(options);
     }
@@ -776,11 +790,16 @@ 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;
 }
 function findVuePackage(capability) {
-    return capability.packages.find((nodePackage) => nodePackage.kind === "vue-app");
+    return capability.packages.find((nodePackage) => nodePackage.kind === "vue-app" || nodePackage.kind === "vike-app");
 }
 function sourceRootPreset(capability) {
     if (capability.packages.length === 1) {
@@ -807,6 +826,9 @@ function projectPackageScripts(checkPlan, fixPlan, fragments) {
     };
 }
 function packageCollection(workspacePackageGlob) {
+    if (workspacePackageGlob === ".") {
+        return ".";
+    }
     return workspacePackageGlob.slice(0, -"/*".length);
 }
 function workspacePackagePath(context, capability) {
@@ -860,6 +882,9 @@ 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}`;
 }
@@ -991,6 +1016,50 @@ function vuePackageJson(context, packageName, scripts, packageLinkDependencies =
         },
     };
 }
+function vikePackageJson(context, packageName, scripts) {
+    return {
+        name: packageName,
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        imports: {
+            "#/*": {
+                default: "./*.ts",
+                types: "./*.ts",
+            },
+        },
+        scripts,
+        dependencies: {
+            "@vikejs/hono": "catalog:",
+            "drizzle-orm": "catalog:",
+            hono: "catalog:",
+            telefunc: "catalog:",
+            vike: "catalog:",
+            "vike-vue": "catalog:",
+            vue: "catalog:",
+        },
+        devDependencies: {
+            "@playwright/test": "catalog:",
+            "@tailwindcss/vite": "catalog:",
+            "@types/node": "catalog:",
+            "@vitejs/plugin-vue": "catalog:",
+            "@vue/tsconfig": "catalog:",
+            "drizzle-kit": "catalog:",
+            oxfmt: "catalog:",
+            oxlint: "catalog:",
+            "oxlint-tsgolint": "catalog:",
+            tailwindcss: "catalog:",
+            typescript: "catalog:",
+            vite: "catalog:",
+            vitest: "catalog:",
+            "vue-tsc": "catalog:",
+        },
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
 function catalogDependencies(dependencies) {
     return Object.fromEntries([...dependencies].toSorted().map((dependency) => [dependency, "catalog:"]));
 }
@@ -1315,9 +1384,17 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
                 ? undefined
                 : packageManifestExposureFields(exposure));
         }
+        if (nodePackage.kind === "vike-app") {
+            return vikePackageJson(context, packageName, scripts);
+        }
         return vuePackageJson(context, packageName, scripts, packageLinkPlan.manifestDependenciesByPackagePath.get(nodePackage.path));
     });
-    const rootManifest = rootPackageJson(context, packageScripts, state);
+    const rootManifest = isRootNodeWorkspace(capability)
+        ? packageManifests[0]
+        : rootPackageJson(context, packageScripts, state);
+    if (rootManifest === undefined) {
+        throw new Error("workspace-node-packages rendered no package manifests");
+    }
     return [
         {
             kind: "writeJson",
@@ -1377,16 +1454,20 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
             text: gitignoreForNodeWorkspace(capability),
         },
         ...capability.packages.flatMap((nodePackage, index) => [
-            {
-                kind: "writeJson",
-                to: `${nodePackage.path}/package.json`,
-                value: packageManifests[index],
-            },
+            ...(nodePackage.path === "."
+                ? []
+                : [
+                    {
+                        kind: "writeJson",
+                        to: `${nodePackage.path}/package.json`,
+                        value: packageManifests[index],
+                    },
+                ]),
             ...nodePackageTsconfigOperations(nodePackage, capability),
             ...nodePackage.sourceFiles.map((sourceFile) => ({
                 kind: "copyFile",
                 from: sourceFile,
-                to: `${nodePackage.path}/${sourcePathWithinNodePackage(sourceFile, capability)}`,
+                to: nodePackageTargetPath(nodePackage, sourceFile, capability),
             })),
         ]),
         ...fullStackApiAnchorOperations(context, capability),
@@ -1439,6 +1520,43 @@ function nodePackageScripts(nodePackage, workspace) {
             typecheck: "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),
+            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",
+            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",
+        };
+    }
     const checks = {
         components: [
             { kind: "oxc-format-check", owner: workspacePackageBoundary },
@@ -1471,6 +1589,80 @@ function nodePackageScripts(nodePackage, workspace) {
     };
 }
 function nodePackageTsconfigOperations(nodePackage, workspace) {
+    if (nodePackage.kind === "vike-app") {
+        return [
+            {
+                kind: "writeJson",
+                to: "tsconfig.app.json",
+                value: {
+                    extends: "@vue/tsconfig/tsconfig.dom.json",
+                    compilerOptions: {
+                        ...strictTypeScriptCompilerOptions({
+                            composite: true,
+                            module: "ESNext",
+                            moduleResolution: "Bundler",
+                            paths: { "#/*": ["./*"] },
+                            tsBuildInfoFile: "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+                            types: ["node"],
+                        }),
+                        skipLibCheck: true,
+                    },
+                    include: [
+                        "+server.ts",
+                        "assets/**/*.svg",
+                        "components/**/*.vue",
+                        "database/**/*.ts",
+                        "env.d.ts",
+                        "global.d.ts",
+                        "pages/**/*.ts",
+                        "pages/**/*.vue",
+                        "server/**/*.ts",
+                    ],
+                },
+            },
+            {
+                kind: "writeJson",
+                to: "tsconfig.test.json",
+                value: {
+                    extends: "./tsconfig.app.json",
+                    compilerOptions: {
+                        lib: ["ESNext", "DOM", "DOM.Iterable"],
+                        paths: { "#/*": ["./*"] },
+                        skipLibCheck: true,
+                        tsBuildInfoFile: "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
+                        types: ["node", "vitest/globals"],
+                    },
+                    include: ["database/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+                },
+            },
+            {
+                kind: "writeJson",
+                to: "tsconfig.node.json",
+                multilineArrays: ["include"],
+                value: {
+                    compilerOptions: {
+                        ...strictTypeScriptCompilerOptions({
+                            composite: true,
+                            module: "ESNext",
+                            moduleResolution: "Bundler",
+                            lib: ["ESNext", "DOM", "DOM.Iterable"],
+                            paths: { "#/*": ["./*"] },
+                            tsBuildInfoFile: "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+                            types: ["node"],
+                        }),
+                        skipLibCheck: true,
+                    },
+                    include: [
+                        "drizzle.config.ts",
+                        "playwright.config.ts",
+                        "scripts/**/*.ts",
+                        "vite.config.ts",
+                        "vitest.config.ts",
+                    ],
+                },
+            },
+        ];
+    }
     if (nodePackage.kind === "hono-api") {
         return [
             {
@@ -1619,6 +1811,13 @@ function sourcePathWithinNodePackage(sourceFile, workspace) {
     }
     return sourceFile.replace(/^(api|web)\//, "");
 }
+function nodePackageTargetPath(nodePackage, sourceFile, workspace) {
+    const packageRelativePath = sourcePathWithinNodePackage(sourceFile, workspace);
+    if (nodePackage.path === ".") {
+        return packageRelativePath;
+    }
+    return `${nodePackage.path}/${packageRelativePath}`;
+}
 function gitignoreForNodeWorkspace(workspace) {
     return [
         "node_modules",
@@ -1642,8 +1841,7 @@ function fullStackApiAnchorOperations(context, workspace) {
             path: "apps/web/src/api.ts",
             language: "typescript",
             replacements: {
-                "api-type-import-start": `import type { AppType } from "@${packageScope}/api";\nimport { hc } from "hono/client";\n/*`,
-                "api-type-import-end": "*/",
+                "api-type-imports": `import type { AppType } from "@${packageScope}/api";\nimport { hc } from "hono/client";`,
             },
         },
     ];
@@ -1700,6 +1898,13 @@ function rootTsconfigReferences(workspace) {
                 ? []
                 : [{ path: `./${nodePackage.path}/tsconfig.json` }];
         }
+        if (nodePackage.kind === "vike-app") {
+            return [
+                { path: "./tsconfig.app.json" },
+                { path: "./tsconfig.test.json" },
+                { path: "./tsconfig.node.json" },
+            ];
+        }
         return [
             { path: `./${nodePackage.path}/tsconfig.app.json` },
             { path: `./${nodePackage.path}/tsconfig.test.json` },

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

@@ -6,7 +6,7 @@ export declare const PackageAdditionSupport: {
 export type PackageAdditionSupport = (typeof PackageAdditionSupport)[keyof typeof PackageAdditionSupport];
 export declare const packageAdditionSupportValues: readonly ["supported", "unsupported"];
 export type PackageRole = "runtime-service" | "shared-library";
-export type PackageSourcePreset = "hono-api" | "ts-lib" | "vue-app";
+export type PackageSourcePreset = "hono-api" | "ts-lib" | "vike-app" | "vue-app";
 export type PackageLinkIntent = {
     readonly consumerPackagePath: string;
     readonly providerPackagePath: string;
@@ -77,8 +77,8 @@ export type WorkspaceLibraryPackageCapabilityDeclaration = {
     readonly packageSourcePreset: "ts-lib";
     readonly sourceFiles: readonly string[];
 };
-export type WorkspaceNodePackageKind = "hono-api" | "vue-app";
-export type WorkspaceNodePackagePath = "apps/api" | "apps/web";
+export type WorkspaceNodePackageKind = "hono-api" | "vike-app" | "vue-app";
+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 const: "apps/*";
+                                                readonly enum: readonly [".", "apps/*"];
                                             };
                                             readonly packages: {
                                                 readonly type: "array";
@@ -415,10 +415,10 @@ export declare const presetSourceManifestJsonSchema: {
                                                     readonly required: readonly ["kind", "path", "sourceFiles"];
                                                     readonly properties: {
                                                         readonly kind: {
-                                                            readonly enum: readonly ["hono-api", "vue-app"];
+                                                            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";
@@ -732,7 +732,7 @@ export declare const blueprintJsonSchema: {
                         readonly enum: readonly ["runtime-service", "shared-library"];
                     };
                     readonly sourcePreset: {
-                        readonly enum: readonly ["hono-api", "ts-lib", "vue-app"];
+                        readonly enum: readonly ["hono-api", "ts-lib", "vike-app", "vue-app"];
                     };
                 };
             };
@@ -776,7 +776,7 @@ export declare const projectBlueprintSchema: v.StrictObjectSchema<{
         readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly role: v.OptionalSchema<v.PicklistSchema<["runtime-service", "shared-library"], undefined>, undefined>;
-        readonly sourcePreset: v.OptionalSchema<v.PicklistSchema<["hono-api", "ts-lib", "vue-app"], undefined>, undefined>;
+        readonly sourcePreset: v.OptionalSchema<v.PicklistSchema<["hono-api", "ts-lib", "vike-app", "vue-app"], undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
     readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly consumerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;