@ykdz/template 0.0.21 → 0.0.23

package/node_modules/@ykdz/template-core/dist/dependency-catalog.js

@@ -1,6 +1,17 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const templateInternalDependencyIdentities = new Set([
+    "@typescript/native",
+    "@typescript/typescript6",
+]);
+function assertGeneratedDependencyCatalogBoundary(dependencies) {
+    for (const dependency of dependencies) {
+        if (templateInternalDependencyIdentities.has(dependency)) {
+            throw new Error(`Generated Repository Dependency Catalog cannot include template-internal dependency: ${dependency}`);
+        }
+    }
+}
 function templateRepositoryRoot() {
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
@@ -151,6 +162,7 @@ function renderCatalogKey(key) {
     return key.startsWith("@") ? JSON.stringify(key) : key;
 }
 export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependencies, templateCatalog = loadTemplateDependencyCatalog()) {
+    assertGeneratedDependencyCatalogBoundary(dependencies);
     const catalogStart = workspaceYaml
         .split(/\r?\n/)
         .findIndex((line) => line === "catalog:");
@@ -183,6 +195,7 @@ export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependen
     ].join("\n");
 }
 export function renderGeneratedPnpmWorkspaceYaml(options) {
+    assertGeneratedDependencyCatalogBoundary(options.dependencies);
     const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
     const packages = options.packages ?? ["."];
     const lines = [

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

@@ -1,4 +1,4 @@
-import { type CheckEnvironmentNeed } from "./module-graph.js";
+import { type CheckEnvironmentNeed, type DeploymentCheckEnvironmentNeed } from "./module-graph.js";
 import type { PresetSourceManifest } from "./preset-source.js";
 import { type PresetProjectionSourceRoots } from "./projection-capabilities.js";
 export type GeneratedScenarioSet = "init" | "package-addition-matrix" | "focused";
@@ -28,7 +28,8 @@ export type GeneratedScenarioCommandStep = {
     readonly args: readonly string[];
     readonly cwd: string;
     readonly display: string;
-    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"];
+    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"] | DeploymentCheckEnvironmentNeed["kind"];
+    readonly phase?: "deployment-preparation" | "deployment";
 };
 export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
     readonly env?: Record<string, string> | undefined;

package/node_modules/@ykdz/template-core/dist/generated-scenarios.js

@@ -5,7 +5,7 @@ import { PackageAdditionSupport } from "@ykdz/template-shared";
 import { execa } from "execa";
 import * as v from "valibot";
 import { assembleGenerationContext } from "./generation-context.js";
-import { playwrightBrowserAssetsEnvironmentNeed, } from "./module-graph.js";
+import { deploymentCheckEnvironmentNeeds, playwrightBrowserAssetsEnvironmentNeed, } from "./module-graph.js";
 import { planNextStepInstructions } from "./next-step-instructions.js";
 import { canPlanPackageLinkIntent, } from "./package-linking.js";
 import { findPresetSourceManifestPreset } from "./preset-source.js";
@@ -14,7 +14,7 @@ const defaultDeterministicToolchainEnv = {
     TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
 };
 const defaultFixtureConcurrency = 2;
-const scenarioFingerprintVersion = 1;
+const scenarioFingerprintVersion = 2;
 const storedBlueprintSchema = v.object({
     packages: v.optional(v.array(v.object({
         name: v.string(),
@@ -235,6 +235,11 @@ async function writeScenarioReplayMarker(cache, fingerprint, scenario) {
     await mkdir(cache.directory, { recursive: true });
     await writeFile(path.join(cache.directory, `${fingerprint}.passed`), `${JSON.stringify({ scenario, fingerprint })}\n`, "utf8");
 }
+function deploymentReplayFingerprint(fingerprint) {
+    return createHash("sha256")
+        .update(`${fingerprint}\0docker-engine-available`)
+        .digest("hex");
+}
 export function packageLeafNameForAddedPreset(manifest, presetName) {
     const preset = manifest.presets.find((entry) => entry.name === presetName);
     if (!preset) {
@@ -392,6 +397,36 @@ function machineVerifiableNextStepsForPreset(presetName, projectDir, manifest, o
         };
     });
 }
+function deploymentStepsForPreset(presetName, scenario, projectDir, manifest, options) {
+    if (scenario.set === "init") {
+        return [];
+    }
+    const deploymentChecks = projectionPlanForPreset(presetName, projectDir, manifest, options).checkPlan
+        .deploymentChecks ?? [];
+    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
+    if (!needsDocker) {
+        return [];
+    }
+    return [
+        {
+            id: "check-docker-engine",
+            command: "docker",
+            args: ["info", "--format", "{{.ServerVersion}}"],
+            cwd: projectDir,
+            display: "docker info --format {{.ServerVersion}}",
+            environmentNeedKind: "docker-engine",
+            phase: "deployment-preparation",
+        },
+        {
+            id: "run-deployment-check",
+            command: "pnpm",
+            args: ["run", "check:deployment"],
+            cwd: projectDir,
+            display: "pnpm run check:deployment",
+            phase: "deployment",
+        },
+    ];
+}
 function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, options) {
     if (!scenario.addedPreset || !addedPackagePath) {
         return [];
@@ -431,30 +466,37 @@ export function generatedScenarioQualityGateSteps(manifest, scenario, projectDir
     const addedEnvironmentSteps = generatedScenarioEnvironmentNeedSteps(addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, normalizedOptions), projectDir);
     const existingDisplays = new Set(steps.map((step) => step.display));
     const extraEnvironmentSteps = addedEnvironmentSteps.filter((step) => !existingDisplays.has(step.display));
+    const deploymentSteps = deploymentStepsForPreset(scenario.basePreset, scenario, projectDir, manifest, normalizedOptions);
     if (extraEnvironmentSteps.length === 0) {
-        return steps;
+        return [...steps, ...deploymentSteps];
     }
     const rootCheckIndex = steps.findIndex((step) => step.id === "run-root-check");
     if (rootCheckIndex === -1) {
-        return [...steps, ...extraEnvironmentSteps];
+        return [...steps, ...extraEnvironmentSteps, ...deploymentSteps];
     }
     return [
         ...steps.slice(0, rootCheckIndex),
         ...extraEnvironmentSteps,
         ...steps.slice(rootCheckIndex),
+        ...deploymentSteps,
     ];
 }
 async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options) {
     const steps = generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options);
     const requiresSerializedPlaywrightRootCheck = generatedScenarioRequiresSerializedRootCheck(steps);
     let replayFingerprint;
+    let baseQualityGateReplayed = false;
+    let baseQualityGateMarkerWritten = false;
     for (const step of steps) {
         if (step.id === "install-dependencies") {
             const installResult = await runGeneratedScenarioInstallStep(step, scenario, options);
             replayFingerprint = installResult.fingerprint;
-            if (installResult.replayed) {
-                return;
-            }
+            baseQualityGateReplayed = installResult.baseQualityGateReplayed;
+            continue;
+        }
+        if (baseQualityGateReplayed &&
+            step.phase !== "deployment-preparation" &&
+            step.phase !== "deployment") {
             continue;
         }
         const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
@@ -464,13 +506,57 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
                 logPrefix: scenario.label,
             });
         };
+        if (step.environmentNeedKind === "docker-engine") {
+            try {
+                await runStep();
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                options.reporter.info?.(`-- Skipping deployment check for ${scenario.label}: Docker engine is unavailable (${reason})`);
+                break;
+            }
+            continue;
+        }
+        if (step.phase === "deployment") {
+            const deploymentFingerprint = replayFingerprint === undefined
+                ? undefined
+                : deploymentReplayFingerprint(replayFingerprint);
+            if (deploymentFingerprint !== undefined &&
+                options.replayCache?.read &&
+                (await scenarioReplayMarkerExists(options.replayCache, deploymentFingerprint))) {
+                options.reporter.info?.(`-- Replayed passed deployment fixture ${scenario.label}: ${deploymentFingerprint}`);
+                continue;
+            }
+            try {
+                await runStep();
+            }
+            catch (error) {
+                throw new Error(`Generated deployment command failed for ${scenario.label}; command: ${step.display}. See the cause for the deployment mode, phase, command output, and retained container logs.`, { cause: error });
+            }
+            if (deploymentFingerprint !== undefined && options.replayCache?.write) {
+                await writeScenarioReplayMarker(options.replayCache, deploymentFingerprint, scenario);
+                options.reporter.info?.(`-- Stored passed deployment fixture replay marker for ${scenario.label}: ${deploymentFingerprint}`);
+            }
+            continue;
+        }
         if (step.id === "run-root-check" && requiresSerializedPlaywrightRootCheck) {
             await options.rootCheckLock.run(runStep);
-            continue;
         }
-        await runStep();
+        else {
+            await runStep();
+        }
+        if (step.id === "run-root-check" &&
+            options.replayCache?.write &&
+            replayFingerprint !== undefined) {
+            await writeScenarioReplayMarker(options.replayCache, replayFingerprint, scenario);
+            baseQualityGateMarkerWritten = true;
+            options.reporter.info?.(`-- Stored passed fixture replay marker for ${scenario.label}: ${replayFingerprint}`);
+        }
     }
-    if (options.replayCache?.write && replayFingerprint !== undefined) {
+    if (options.replayCache?.write &&
+        replayFingerprint !== undefined &&
+        !baseQualityGateMarkerWritten &&
+        !baseQualityGateReplayed) {
         await writeScenarioReplayMarker(options.replayCache, replayFingerprint, scenario);
         options.reporter.info?.(`-- Stored passed fixture replay marker for ${scenario.label}: ${replayFingerprint}`);
     }
@@ -482,15 +568,15 @@ async function runGeneratedScenarioInstallStep(step, scenario, options) {
         replayFingerprint = await hashGeneratedScenarioDirectory(scenario, step.cwd);
         if (options.replayCache.read &&
             (await scenarioReplayMarkerExists(options.replayCache, replayFingerprint))) {
-            options.reporter.info?.(`-- Replayed passed fixture ${scenario.label}: ${replayFingerprint}`);
-            return { fingerprint: replayFingerprint, replayed: true };
+            options.reporter.info?.(`-- Replayed passed base quality gate for ${scenario.label}: ${replayFingerprint}`);
+            return { fingerprint: replayFingerprint, baseQualityGateReplayed: true };
         }
     }
     await options.runCommand(step.command, ["fetch"], step.cwd, {
         logPrefix: scenario.label,
     });
     await options.runCommand(step.command, ["install", "--offline", "--frozen-lockfile"], step.cwd, { logPrefix: scenario.label });
-    return { fingerprint: replayFingerprint, replayed: false };
+    return { fingerprint: replayFingerprint, baseQualityGateReplayed: false };
 }
 async function checkGeneratedScenario(manifest, scenario, workspace, options) {
     options.reporter.info?.(`\n== ${scenario.label} ==`);

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

@@ -26,6 +26,13 @@ export type CheckComponent = {
     readonly kind: CheckComponentKind;
     readonly owner: ComponentOwner;
 };
+export type DeploymentCheckComponent = {
+    readonly kind: "deployment-image";
+    readonly owner: PackageBoundaryOwner;
+};
+export type DeploymentCheckEnvironmentNeed = {
+    readonly kind: "docker-engine";
+};
 export type FixComponent = {
     readonly kind: FixComponentKind;
     readonly owner: ComponentOwner;
@@ -33,6 +40,7 @@ export type FixComponent = {
 export type CheckPlan = {
     readonly components: CheckComponent[];
     readonly environmentNeeds: CheckEnvironmentNeed[];
+    readonly deploymentChecks?: DeploymentCheckComponent[] | undefined;
 };
 export type FixPlan = {
     readonly components: FixComponent[];
@@ -43,6 +51,10 @@ export declare function fixComponentTaskName(component: FixComponent): string;
 export declare function renderCheckLeafCommand(component: CheckComponent): string;
 export declare function renderFixLeafCommand(component: FixComponent): string;
 export declare function renderRootCheckCommand(plan: CheckPlan): string;
+export declare function deploymentCheckEnvironmentNeeds(check: DeploymentCheckComponent): DeploymentCheckEnvironmentNeed[];
+export declare function deploymentCheckTaskName(check: DeploymentCheckComponent): "check:deployment";
+export declare function renderDeploymentCheckLeafCommand(check: DeploymentCheckComponent): string;
+export declare function renderDeploymentCheckCommand(plan: Pick<CheckPlan, "deploymentChecks">): string;
 export declare function renderFixCommand(plan: FixPlan): string;
 export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed, options?: {
     readonly withDeps?: boolean;

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

@@ -119,6 +119,24 @@ export function renderRootCheckCommand(plan) {
         "check:run",
     ]));
 }
+export function deploymentCheckEnvironmentNeeds(check) {
+    switch (check.kind) {
+        case "deployment-image":
+            return [{ kind: "docker-engine" }];
+    }
+}
+export function deploymentCheckTaskName(check) {
+    switch (check.kind) {
+        case "deployment-image":
+            return "check:deployment";
+    }
+}
+export function renderDeploymentCheckLeafCommand(check) {
+    return `pnpm --filter './${check.owner.path}' run ${deploymentCheckTaskName(check)}`;
+}
+export function renderDeploymentCheckCommand(plan) {
+    return uniqueTaskNames((plan.deploymentChecks ?? []).map(renderDeploymentCheckLeafCommand)).join(" && ");
+}
 export function renderFixCommand(plan) {
     return renderTurboRunCommand(uniqueTaskNames([
         ...plan.components.flatMap(fixComponentTaskNames),

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

@@ -4,10 +4,12 @@ packages:
 nodeLinker: hoisted
 
 catalog:
+  "@typescript/native": npm:typescript@^7.0.2
+  "@typescript/typescript6": ^6.0.2
   "@hono/node-server": ^2.0.6
   "@playwright/test": ^1.61.1
   "@tailwindcss/vite": ^4.3.2
-  "@types/node": ^24.0.0
+  "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
   "@vitejs/plugin-vue": ^6.0.7
   "@vikejs/hono": ^0.2.1
@@ -17,17 +19,18 @@ catalog:
   execa: ^9.6.1
   hono: ^4.12.27
   oxfmt: ^0.58.0
-  oxlint: ^1.72.0
+  oxlint: ^1.73.0
   oxlint-tsgolint: ^0.24.0
   pinia: ^3.0.4
+  srvx: ^0.11.21
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
   tsc-alias: ^1.8.17
-  tsx: ^4.22.4
+  tsx: ^4.23.0
   turbo: 2.10.2
   typescript: ^6.0.3
   valibot: ^1.4.2
-  vite: ^8.1.2
+  vite: ^8.1.4
   vike: ^0.4.260
   vike-vue: ^0.9.12
   vitest: ^4.1.10

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

@@ -17,6 +17,7 @@ export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
     readonly ecosystems: DependencyEcosystem[];
     readonly directories?: Partial<Record<DependencyEcosystem, DependabotDirectory>>;
+    readonly extraDirectories?: Partial<Record<DependencyEcosystem, readonly DependabotDirectory[]>>;
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {

package/node_modules/@ykdz/template-core/dist/project-github.js

@@ -1,4 +1,4 @@
-import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { deploymentCheckEnvironmentNeeds, deploymentCheckTaskName, renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -16,6 +16,8 @@ export function projectCheckWorkflow(options) {
         ...options.environmentPreparation,
     };
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
+    const deploymentChecks = options.checkPlan.deploymentChecks ?? [];
+    const needsDocker = deploymentChecks.some((check) => deploymentCheckEnvironmentNeeds(check).some((need) => need.kind === "docker-engine"));
     const lines = [
         `name: ${capability.workflowName}`,
         "",
@@ -34,12 +36,20 @@ export function projectCheckWorkflow(options) {
     if (environmentPreparation.nodeFromPackageMetadata) {
         lines.push("      - uses: actions/setup-node@v6", "        with:", "          node-version-file: package.json", "      - run: corepack enable");
     }
+    if (needsDocker) {
+        lines.push("      - uses: docker/setup-buildx-action@v3");
+    }
     if (environmentPreparation.rustToolchain) {
         lines.push("      - uses: dtolnay/rust-toolchain@stable", "        with:", "          components: rustfmt, clippy", "      - uses: Swatinem/rust-cache@v2");
     }
     lines.push(`      - run: ${taskLayer.installCommand}`);
     lines.push(...options.checkPlan.environmentNeeds.map((need) => `      - run: ${renderCiEnvironmentNeedCommand(need)}`));
-    lines.push(`      - run: ${taskLayer.checkCommand}`, "");
+    lines.push(`      - run: ${taskLayer.checkCommand}`);
+    const deploymentCheck = deploymentChecks[0];
+    if (deploymentCheck !== undefined) {
+        lines.push(`      - run: pnpm run ${deploymentCheckTaskName(deploymentCheck)}`);
+    }
+    lines.push("");
     return lines.join("\n");
 }
 export function projectDependabotConfig(policy) {
@@ -47,8 +57,11 @@ export function projectDependabotConfig(policy) {
         "version: 2",
         "",
         "updates:",
-        ...policy.ecosystems.flatMap((ecosystem) => renderDependabotUpdate(ecosystem, policy.directories?.[ecosystem] ??
-            defaultDependabotDirectory(ecosystem), policy.interval)),
+        ...policy.ecosystems.flatMap((ecosystem) => [
+            policy.directories?.[ecosystem] ??
+                defaultDependabotDirectory(ecosystem),
+            ...(policy.extraDirectories?.[ecosystem] ?? []),
+        ].flatMap((directory) => renderDependabotUpdate(ecosystem, directory, policy.interval))),
         "",
     ].join("\n");
 }
@@ -62,7 +75,7 @@ function renderDependabotUpdate(ecosystem, directory, interval) {
     if (ecosystem === "npm") {
         lines.push("    groups:", "      drizzle:", "        patterns:", '          - "drizzle-*"', '          - "drizzle-orm"', "    ignore:", '      - dependency-name: "@types/node"', "        update-types:", "          - version-update:semver-major");
     }
-    if (ecosystem === "docker") {
+    if (ecosystem === "docker" && directory === "/.devcontainer") {
         lines.push("    ignore:", "      - dependency-name: mcr.microsoft.com/devcontainers/typescript-node", "        update-types:", "          - version-update:semver-major");
     }
     return lines;

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

@@ -4,7 +4,7 @@ import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, valid
 import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderCargoLockForPackage, renderGeneratedPnpmWorkspaceYaml, renderCargoDependencyTomlEntries, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
 import { editorCustomizationForCapabilities, loadEditorCustomizationDeclarations, } from "./editor-customization.js";
-import { playwrightBrowserAssetsEnvironmentNeed, renderCheckLeafCommand, renderFixCommand, renderFixLeafCommand, renderRootCheckCommand, renderTurboRunCommand, } from "./module-graph.js";
+import { playwrightBrowserAssetsEnvironmentNeed, renderDeploymentCheckCommand, renderCheckLeafCommand, renderFixCommand, renderFixLeafCommand, renderRootCheckCommand, renderTurboRunCommand, } from "./module-graph.js";
 import { packageManifestExposureFields, packageTurboConfig, planPackageLinks, } from "./package-linking.js";
 export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
 const strictTypescriptRootBoundary = {
@@ -77,6 +77,13 @@ const capabilityInterpreters = {
             state.nodeWorkspace = capability;
             state.sourceRoot = templateSourceRootForPreset(state, sourceRootPreset(capability));
             state.operationFactories.push(workspaceNodePackagesOperations);
+            if (hasVikePackage(capability)) {
+                state.dependencyMaintenanceExtraDirectories.docker = ["/apps/web"];
+                state.deploymentCheckComponents.push({
+                    kind: "deployment-image",
+                    owner: { kind: "package-boundary", path: "apps/web" },
+                });
+            }
             if (capability.packages.length > 1) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
             }
@@ -277,6 +284,9 @@ export function interpretPresetProjectionDeclaration(options) {
     const checkPlan = {
         components: state.rootCheckComponents,
         environmentNeeds: state.rootCheckEnvironmentNeeds,
+        ...(state.deploymentCheckComponents.length === 0
+            ? {}
+            : { deploymentChecks: state.deploymentCheckComponents }),
     };
     const fixPlan = {
         components: state.rootFixComponents,
@@ -285,6 +295,7 @@ export function interpretPresetProjectionDeclaration(options) {
     const packageScriptsByPath = packageScriptsByWorkspacePath(state);
     const dependencyMaintenancePolicy = {
         ecosystems: uniqueValues(state.dependencyMaintenanceEcosystems),
+        extraDirectories: state.dependencyMaintenanceExtraDirectories,
         ...(state.rustWorkspace === undefined
             ? {}
             : {
@@ -383,6 +394,7 @@ function createProjectionCompositionState(sourceRoots) {
         sourceRoots: {},
         rootCheckComponents: [],
         rootCheckEnvironmentNeeds: [],
+        deploymentCheckComponents: [],
         packageCheckComponents: [],
         rootFixComponents: [],
         packageFixComponents: [],
@@ -392,6 +404,7 @@ function createProjectionCompositionState(sourceRoots) {
         packageDependencies: new Set(),
         packageDevDependencies: new Set(),
         dependencyMaintenanceEcosystems: [],
+        dependencyMaintenanceExtraDirectories: {},
         editorCustomizationCapabilities: [],
         operationFactories: [],
         flags: {},
@@ -752,6 +765,9 @@ function projectRootPackageScripts(checkPlan, fixPlan, fragments) {
     const directFragments = directScriptFragments(fragments);
     return {
         check: `pnpm run check:boundaries && ${renderRootCheckCommand(checkPlan)}`,
+        ...(checkPlan.deploymentChecks === undefined
+            ? {}
+            : { "check:deployment": renderDeploymentCheckCommand(checkPlan) }),
         fix: renderFixCommand(fixPlan),
         ...rootTaskEntrypoints(checkPlan, fixPlan),
         ...directFragments,
@@ -1057,7 +1073,9 @@ function vikePackageJson(context, packageName, scripts, packageLinkDependencies
         dependencies: {
             ...packageLinkDependencies,
             "@vikejs/hono": "catalog:",
+            "drizzle-orm": "catalog:",
             hono: "catalog:",
+            srvx: "catalog:",
             telefunc: "catalog:",
             vike: "catalog:",
             "vike-vue": "catalog:",
@@ -1110,6 +1128,10 @@ function vikeDbPackageJson(context) {
                 default: "./src/queries/todos.ts",
                 types: "./src/queries/todos.ts",
             },
+            "./readiness": {
+                default: "./src/readiness.ts",
+                types: "./src/readiness.ts",
+            },
         },
         dependencies: {
             "drizzle-orm": "catalog:",
@@ -1132,15 +1154,19 @@ function vikeDbPackageJson(context) {
 function vikeDbPackageScripts() {
     return {
         "build:run": "tsc -p tsconfig.json --noEmit",
+        "db:generate": "drizzle-kit generate",
+        "db:migrate": "drizzle-kit migrate",
+        "db:prepare:deploy": "pnpm run db:migrate",
+        "db:prepare:dev": "pnpm run db:push && pnpm run db:seed:example",
+        "db:prepare:test": 'rm -f "${DATABASE_FILE:-./node_modules/.tmp/test.sqlite}" && pnpm run db:push && pnpm run db:seed:example',
         "db:push": "mkdir -p data node_modules/.tmp && drizzle-kit push",
-        "drizzle:generate": "drizzle-kit generate",
-        "drizzle:migrate": "drizzle-kit migrate",
-        "drizzle:studio": "drizzle-kit studio",
+        "db:seed:example": "node --experimental-strip-types scripts/seed-example.ts",
+        "db:studio": "drizzle-kit studio",
         "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
         "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
         "lint:run": "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
         "lint:fix:run": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
-        "test:run": "DATABASE_FILE=./node_modules/.tmp/test.sqlite pnpm run db:push && DATABASE_FILE=./node_modules/.tmp/test.sqlite vitest run --reporter=agent --silent=passed-only",
+        "test:run": "DATABASE_FILE=./node_modules/.tmp/test.sqlite pnpm run db:prepare:test && DATABASE_FILE=./node_modules/.tmp/test.sqlite vitest run --reporter=agent --silent=passed-only; status=$?; rm -f ./node_modules/.tmp/test.sqlite; exit $status",
         "typecheck:run": "tsc -p tsconfig.json --noEmit --pretty false",
     };
 }
@@ -1565,9 +1591,10 @@ function nodePackageScripts(nodePackage, workspace) {
         };
     }
     if (nodePackage.kind === "vike-app") {
-        const dbCommand = "DATABASE_FILE=../../apps/web/data/app.sqlite pnpm --dir ../../packages/db run db:push";
+        const dbCommand = "DATABASE_FILE=../../apps/web/data/app.sqlite pnpm --dir ../../packages/db run db:prepare:dev";
         return {
             "build:run": "vike build",
+            "check:deployment": "node --experimental-strip-types scripts/check-standalone-deployment.ts",
             dev: `${dbCommand} && vike dev`,
             "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
             "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
@@ -1836,6 +1863,21 @@ function vikeTemplateSourceOperation(options) {
         from: options.sourceFile,
         to,
     };
+    if (options.nodePackage.kind === "vike-app" &&
+        options.sourceFile === "web/Dockerfile") {
+        return [
+            {
+                kind: "writeTextTemplate",
+                from: options.sourceFile,
+                to,
+                replacements: {
+                    NODE_VERSION: options.context.toolchain.nodeLtsMajor.value,
+                    PACKAGE_MANAGER_PIN: options.context.toolchain.packageManagerPin.value,
+                    WEB_PACKAGE_NAME: nodePackageName(options.context, options.nodePackage),
+                },
+            },
+        ];
+    }
     if (options.nodePackage.kind === "vike-app" &&
         [
             "web/pages/index/+Page.telefunc.ts",
@@ -1845,7 +1887,10 @@ function vikeTemplateSourceOperation(options) {
         const dbPackageName = vikeDbPackageName(options.context);
         const replacements = {
             "web/pages/index/+Page.telefunc.ts": `import { createTodo, listTodos } from "${dbPackageName}/queries/todos";`,
-            "web/server/app.ts": `import { createDatabase } from "${dbPackageName}";`,
+            "web/server/app.ts": [
+                `import { createDatabase } from "${dbPackageName}";`,
+                `import { assertDatabaseReady } from "${dbPackageName}/readiness";`,
+            ].join("\n"),
             "web/types/global.d.ts": `import type { Database } from "${dbPackageName}";`,
         };
         return [
@@ -1865,9 +1910,14 @@ function vikeTemplateSourceOperation(options) {
 const vikeDbSourceFiles = [
     "db/turbo.json",
     "db/drizzle.config.ts",
+    "db/drizzle/migrations/20260709120325_old_captain_flint/migration.sql",
+    "db/drizzle/migrations/20260709120325_old_captain_flint/snapshot.json",
+    "db/scripts/seed-example.ts",
     "db/src/db.ts",
     "db/src/index.ts",
     "db/src/queries/todos.ts",
+    "db/src/readiness.ts",
+    "db/src/seed/example.ts",
     "db/src/schema.ts",
     "db/test/todos.test.ts",
 ];

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

@@ -216,6 +216,9 @@ function assertTextTemplatePath(relativePath) {
     if (/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/(?:playwright|vite|vitest|oxfmt|oxlint)\.config\.ts$/.test(normalizedPath)) {
         return;
     }
+    if (/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/Dockerfile$/.test(normalizedPath)) {
+        return;
+    }
     assertFoundationTextPath(relativePath);
 }
 async function renderWriteText(operation, options) {
@@ -293,7 +296,7 @@ function parseAnchorComment(commentText) {
     return multiline?.[1];
 }
 async function findTypeScriptAnchorRanges(sourceText) {
-    const ts = await import("typescript");
+    const ts = await import("@typescript/typescript6");
     const sourceFile = ts.createSourceFile("template-anchor.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const anchors = [];
     const seenRanges = new Set();

package/node_modules/@ykdz/template-core/dist/template-boundary-check.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import ts from "typescript";
+import ts from "@typescript/typescript6";
 const inlineOperationKinds = new Set([
     "writeText",
     "writeJson",

package/node_modules/@ykdz/template-core/package.json

@@ -25,12 +25,13 @@
     "typecheck": "tsc -p tsconfig.json --noEmit --pretty false"
   },
   "dependencies": {
+    "@typescript/typescript6": "catalog:",
     "@ykdz/template-shared": "workspace:*",
-    "typescript": "catalog:",
     "valibot": "catalog:"
   },
   "devDependencies": {
     "@types/node": "catalog:",
+    "@typescript/native": "catalog:",
     "execa": "catalog:",
     "oxfmt": "catalog:",
     "oxlint": "catalog:",