@ykdz/template 0.0.12 → 0.0.14

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,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) {
@@ -793,20 +812,110 @@ 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),
     };
 }
+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 rootEntrypointScriptsFromRootPackageScripts(scripts) {
+    return Object.fromEntries(Object.entries(scripts).filter(([scriptName]) => !scriptName.endsWith(":run") ||
+        scriptName === "check:run" ||
+        scriptName === "fix:run"));
+}
+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) {
+    if (workspacePackageGlob === ".") {
+        return ".";
+    }
     return workspacePackageGlob.slice(0, -"/*".length);
 }
 function workspacePackagePath(context, capability) {
@@ -860,6 +969,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 +1103,51 @@ 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:",
+            turbo: "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:"]));
 }
@@ -1062,17 +1219,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");
@@ -1108,14 +1273,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,
                 },
             },
         },
@@ -1154,18 +1312,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));
@@ -1201,12 +1355,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
             kind: "writeJson",
             to: "turbo.json",
             value: {
-                tasks: {
-                    check: {},
-                    fix: {
-                        cache: false,
-                    },
-                },
+                tasks: packageTurboTasks({ dependencyBuildsRequired: false }),
             },
         },
         {
@@ -1269,6 +1418,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, package
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
             value: developmentContainer.devcontainer,
+            multilineArrays: ["customizations.vscode.extensions"],
         },
         {
             ...developmentContainer.dockerfileOperation,
@@ -1315,9 +1465,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)
+        ? rootNodePackageManifest(packageManifests[0], packageScripts)
+        : rootPackageJson(context, packageScripts, state);
+    if (rootManifest === undefined) {
+        throw new Error("workspace-node-packages rendered no package manifests");
+    }
     return [
         {
             kind: "writeJson",
@@ -1352,11 +1510,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: {
@@ -1365,9 +1519,6 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
                             },
                         }
                         : {}),
-                    fix: {
-                        cache: false,
-                    },
                 },
             },
         },
@@ -1377,16 +1528,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),
@@ -1402,6 +1557,33 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
         },
     ];
 }
+function rootNodePackageManifest(packageManifest, rootPackageScripts) {
+    if (packageManifest === undefined) {
+        return undefined;
+    }
+    const packageScripts = packageManifest.scripts;
+    if (packageScripts === undefined ||
+        typeof packageScripts !== "object" ||
+        packageScripts === null ||
+        Array.isArray(packageScripts)) {
+        throw new Error("Root node package manifest rendered invalid scripts");
+    }
+    const checkedPackageScripts = {};
+    for (const scriptName of Object.keys(packageScripts)) {
+        const command = Reflect.get(packageScripts, scriptName);
+        if (typeof command !== "string") {
+            throw new Error("Root node package manifest rendered non-string scripts");
+        }
+        checkedPackageScripts[scriptName] = command;
+    }
+    return {
+        ...packageManifest,
+        scripts: {
+            ...rootEntrypointScriptsFromRootPackageScripts(rootPackageScripts),
+            ...checkedPackageScripts,
+        },
+    };
+}
 function nodePackageScripts(nodePackage, workspace) {
     const oxcScripts = {
         "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
@@ -1410,67 +1592,122 @@ 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") {
+        return {
+            "build:run": "vike build",
+            dev: "vike dev",
+            "drizzle:generate": "drizzle-kit generate",
+            "drizzle:migrate": "drizzle-kit migrate",
+            "drizzle:studio": "drizzle-kit studio",
+            "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: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",
     };
 }
 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 +1856,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 +1886,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 +1943,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` },
@@ -1761,6 +2011,7 @@ function nodePnpmDevcontainerOperations({ context, state, }) {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
             value: developmentContainer.devcontainer,
+            multilineArrays: ["customizations.vscode.extensions"],
         },
         {
             ...developmentContainer.dockerfileOperation,