@ykdz/template 0.0.35 → 0.0.37

package/node_modules/@ykdz/template-builtin-presets/dist/src/vike-app/definition.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
-import { dockerEngineEnvironmentNeed, playwrightBrowserAssetsEnvironmentNeed, shellCheckEnvironmentNeed, } from "#template-core/module-graph";
+import { dockerEngineEnvironmentNeed, playwrightBrowserAssetsEnvironmentNeed, } from "@ykdz/template-core/module-graph";
+import { definePackageContributionReplayAdapter, } from "@ykdz/template-core/preset-definition";
 import { browserTestDevelopmentContainerToolLayer } from "../shared/development-container.js";
 import { typescriptConfigSourceOperation } from "../shared/typescript.js";
 import { vueTypecheckRunnerSourceOperation } from "../shared/vue.js";
@@ -7,121 +8,85 @@ import { templateSources } from "../template-sources.js";
 function definitions(context) {
     return {
         web: {
-            name: `@${context.scope}/web`,
+            name: `@${context.defaultPackageScope}/web`,
             path: "apps/web",
             role: "runtime-service",
         },
         db: {
-            name: `@${context.scope}/db`,
+            name: `@${context.defaultPackageScope}/db`,
             path: "packages/db",
             role: "shared-library",
         },
         migrations: {
-            name: `@${context.scope}/db-migrations`,
+            name: `@${context.defaultPackageScope}/db-migrations`,
             path: "packages/db-migrations",
             role: "shared-library",
         },
     };
 }
-function foundation() {
+function replayDefinitions(initialPackages) {
+    return {
+        web: initialPackages.require("web"),
+        db: initialPackages.require("database"),
+        migrations: initialPackages.require("migrations"),
+    };
+}
+function foundation(packageDefinitions) {
+    const workspacePackageGlobs = [
+        ...new Set(Object.values(packageDefinitions).map((definition) => `${definition.path.split("/")[0]}/*`)),
+    ];
     return {
         toolchains: {},
         editorCapabilities: ["oxc-format-lint", "vue", "tailwind", "vitest"],
+        typescriptConfigurationPackage: { dependency: "required" },
         dependencyMaintenance: {
             ecosystems: ["npm", "github-actions", "docker"],
             directories: { npm: "/", docker: "/.devcontainer" },
-            extraDirectories: { docker: ["/apps/web"] },
             interval: "weekly",
         },
-        workspacePackageGlobs: ["apps/*", "packages/*"],
-    };
-}
-function shellCheckDevelopmentContainerToolLayer() {
-    return {
-        identity: "shellcheck",
-        dockerfile: {
-            source: templateSources.vikeApp,
-            from: "devcontainer/shellcheck.Dockerfile",
-        },
-        requires: ["node-pnpm"],
-        probes: [
-            { identity: "shellcheck", command: "shellcheck", args: ["--version"] },
-        ],
-    };
-}
-function dockerClientDevelopmentContainerToolLayer() {
-    return {
-        identity: "docker-client",
-        dockerfile: {
-            source: templateSources.vikeApp,
-            from: "devcontainer/docker-client.Dockerfile",
-        },
-        requires: ["node-pnpm"],
-        mounts: [
-            {
-                identity: "docker-socket",
-                type: "bind",
-                source: "/var/run/docker.sock",
-                target: "/var/run/docker.sock",
-            },
-        ],
-        probes: [
-            {
-                identity: "docker-cli",
-                command: "docker",
-                args: ["--version"],
-                failureMessage: "Docker CLI is unavailable; rebuild the Development Container to install the Docker Client Tool Layer.",
-            },
-            {
-                identity: "docker-daemon",
-                command: "docker",
-                args: ["version"],
-                failureMessage: "Docker daemon is inaccessible through /var/run/docker.sock; verify the host daemon is running and the standard socket is accessible.",
-            },
-        ],
+        workspacePackageGlobs,
     };
 }
 function webScripts() {
     return {
         build: "vike build",
-        deployment: "node --conditions=source scripts/check-standalone-deployment.ts",
-        dev: "vike dev",
-        "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
-        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
-        lint: "shellcheck scripts/container-entrypoint.sh && oxlint --quiet --format=unix --type-aware --config ../../oxlint.config.ts .",
-        "lint:fix": "oxlint --type-aware --format=unix --config ../../oxlint.config.ts . --fix",
-        preview: "vike preview",
+        dev: "DATABASE_PROFILE=dev NODE_OPTIONS=--conditions=source vike dev",
+        "format:check": "oxfmt --list-different .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint --quiet --format=unix --type-aware .",
+        "lint:fix": "oxlint --type-aware --format=unix . --fix",
+        preview: "DATABASE_PROFILE=dev vike preview",
         start: "node ./dist/server/index.mjs",
         test: "vitest run --reporter=agent --silent=passed-only --passWithNoTests",
-        "test:e2e": "playwright test",
+        "test:e2e": "DATABASE_PROFILE=e2e playwright test",
         typecheck: "node --conditions=source scripts/run-vue-tsc.ts --build --noEmit --pretty false",
     };
 }
 function databaseScripts() {
     return {
-        build: "tsc -p tsconfig.build.json --noEmit",
+        build: "tsc -p tsconfig.build.json --pretty false",
         "db:seed:example": "node --conditions=source scripts/seed-example.ts",
-        "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
-        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
-        lint: "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
-        "lint:fix": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
-        test: "vitest run --reporter=agent --silent=passed-only",
+        "db:reset": "node --conditions=source scripts/reset.ts",
+        "format:check": "oxfmt --list-different .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint --quiet --format=unix .",
+        "lint:fix": "oxlint --format=unix . --fix",
+        test: "DATABASE_PROFILE=test NODE_OPTIONS=--conditions=source vitest run --reporter=agent --silent=passed-only",
         typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
     };
 }
-function migrationScripts(databasePackageName) {
-    const withDatabasePackage = (command) => `DATABASE_PACKAGE_NAME=${databasePackageName} ${command}`;
+function migrationScripts() {
     return {
         build: "tsc -p tsconfig.build.json --noEmit",
-        "db:generate": withDatabasePackage("drizzle-kit generate"),
-        "db:migrate": withDatabasePackage("drizzle-kit migrate"),
+        "db:generate": "DATABASE_PROFILE=dev NODE_OPTIONS=--conditions=source drizzle-kit generate",
+        "db:migrate": "drizzle-kit migrate",
         "db:prepare:deploy": "pnpm run db:migrate",
-        "db:push": withDatabasePackage("drizzle-kit push"),
-        "db:studio": withDatabasePackage("drizzle-kit studio"),
-        "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
-        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
-        lint: "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
-        "lint:fix": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
+        "db:push": "NODE_OPTIONS=--conditions=source drizzle-kit push",
+        "db:studio": "DATABASE_PROFILE=dev NODE_OPTIONS=--conditions=source drizzle-kit studio",
+        "format:check": "oxfmt --list-different .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint --quiet --format=unix .",
+        "lint:fix": "oxlint --format=unix . --fix",
         typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
     };
 }
@@ -149,12 +114,11 @@ function copyOperations(context, packagePath, sourceFiles) {
             };
     });
 }
-function webContribution(context) {
-    const { web, db } = definitions(context);
+function webContribution(context, packageDefinitions = definitions(context)) {
+    const { web, db, migrations } = packageDefinitions;
     const sourceFiles = [
         "web/+server.ts",
         "web/.env.example",
-        "web/Dockerfile.dockerignore",
         "web/assets/logo.svg",
         "web/components/CounterButton.vue",
         "web/components/PageShell.vue",
@@ -164,14 +128,11 @@ function webContribution(context) {
         "web/pages/index/+Page.vue",
         "web/pages/tailwind.css",
         "web/playwright.config.ts",
-        "web/scripts/check-standalone-deployment.ts",
-        "web/scripts/container-entrypoint.sh",
         "web/server/api.ts",
         "web/test/playwright-teardown.ts",
         "web/test/e2e/app.spec.ts",
         "web/turbo.json",
         "web/types/env.d.ts",
-        "web/vite.config.ts",
         "web/vitest.config.ts",
         "web/tsconfig.json",
         "web/tsconfig.app.json",
@@ -189,15 +150,9 @@ function webContribution(context) {
         {
             kind: "writeTextTemplate",
             source: templateSources.vikeApp,
-            from: "web/Dockerfile",
-            to: `${web.path}/Dockerfile`,
-            replacements: {
-                NODE_VERSION: context.toolchain.nodeLtsMajor,
-                PACKAGE_MANAGER_PIN: context.toolchain.packageManagerPin,
-                DB_PACKAGE_NAME: definitions(context).db.name,
-                DB_MIGRATIONS_PACKAGE_NAME: definitions(context).migrations.name,
-                WEB_PACKAGE_NAME: web.name,
-            },
+            from: "web/vite.config.ts",
+            to: `${web.path}/vite.config.ts`,
+            replacements: { DB_PACKAGE_NAME: db.name },
         },
         {
             kind: "copyFile",
@@ -242,11 +197,6 @@ function webContribution(context) {
             },
         },
         vueTypecheckRunnerSourceOperation(web.path),
-        {
-            kind: "setExecutable",
-            path: `${web.path}/scripts/container-entrypoint.sh`,
-            executable: true,
-        },
     ];
     const owner = { kind: "package-boundary", path: web.path };
     return {
@@ -265,7 +215,6 @@ function webContribution(context) {
         },
         manifest: {
             name: web.name,
-            version: "0.0.0",
             private: true,
             type: "module",
             files: ["dist"],
@@ -310,62 +259,115 @@ function webContribution(context) {
         operations,
         environmentNeeds: [
             playwrightBrowserAssetsEnvironmentNeed({ browser: "chromium", owner }),
-            shellCheckEnvironmentNeed(owner),
         ],
         ciDiagnosticArtifacts: [{ kind: "playwright", owner }],
-        deploymentEnvironmentNeeds: [dockerEngineEnvironmentNeed()],
         foundation: {
-            ...foundation(),
+            ...foundation(packageDefinitions),
+            deploymentCheck: {
+                kind: "application-container-with-database-migrations",
+                applicationPackageName: web.name,
+                databasePackageName: db.name,
+                migrationPackageName: migrations.name,
+                environmentNeeds: [dockerEngineEnvironmentNeed()],
+                sources: {
+                    checker: {
+                        source: templateSources.vikeApp,
+                        from: "web/scripts/check-standalone-deployment.ts",
+                    },
+                    controlScript: {
+                        source: templateSources.vikeApp,
+                        from: "web/scripts/container-entrypoint.sh",
+                    },
+                    dockerfile: {
+                        source: templateSources.vikeApp,
+                        from: "web/Dockerfile",
+                    },
+                    dockerIgnore: {
+                        source: templateSources.vikeApp,
+                        from: "web/Dockerfile.dockerignore",
+                    },
+                    shellCheckDockerfile: {
+                        source: templateSources.vikeApp,
+                        from: "devcontainer/shellcheck.Dockerfile",
+                    },
+                    dockerClientToolLayer: {
+                        source: templateSources.vikeApp,
+                        from: "devcontainer/docker-client.Dockerfile",
+                    },
+                },
+            },
             developmentContainerToolLayers: [
                 browserTestDevelopmentContainerToolLayer(),
-                shellCheckDevelopmentContainerToolLayer(),
-                dockerClientDevelopmentContainerToolLayer(),
             ],
         },
     };
 }
-function databaseContribution(context) {
-    const { db } = definitions(context);
+function databaseContribution(context, packageDefinitions = definitions(context)) {
+    const { db, migrations, web } = packageDefinitions;
     const sourceFiles = [
         "db/turbo.json",
         "db/tsconfig.json",
         "db/tsconfig.build.json",
         "db/scripts/seed-example.ts",
-        "db/vitest.config.ts",
-        "db/test/global-setup.ts",
+        "db/scripts/reset.ts",
         "db/src/db.ts",
         "db/src/index.ts",
         "db/src/queries/todos.ts",
         "db/src/readiness.ts",
+        "db/src/storage.ts",
         "db/src/seed/example.ts",
         "db/src/schema.ts",
-        "db/src/types.d.ts",
+        "db/src/types.ts",
         "db/test/todos.test.ts",
     ];
     const exposure = {
         exports: {
-            ".": { default: "./src/index.ts", types: "./src/index.ts" },
-            "./schema": { default: "./src/schema.ts", types: "./src/schema.ts" },
-            "./types": { default: "./src/types.d.ts", types: "./src/types.d.ts" },
+            ".": {
+                source: "./src/index.ts",
+                types: "./dist/index.d.ts",
+                default: "./dist/index.js",
+            },
             "./queries/todos": {
-                default: "./src/queries/todos.ts",
-                types: "./src/queries/todos.ts",
+                source: "./src/queries/todos.ts",
+                types: "./dist/queries/todos.d.ts",
+                default: "./dist/queries/todos.js",
             },
             "./readiness": {
-                default: "./src/readiness.ts",
-                types: "./src/readiness.ts",
+                source: "./src/readiness.ts",
+                types: "./dist/readiness.d.ts",
+                default: "./dist/readiness.js",
+            },
+            "./schema": {
+                source: "./src/schema.ts",
+                types: "./dist/schema.d.ts",
+                default: "./dist/schema.js",
+            },
+            "./storage": {
+                source: "./src/storage.ts",
+                types: "./dist/storage.d.ts",
+                default: "./dist/storage.js",
+            },
+            "./types": {
+                source: "./src/types.ts",
+                types: "./dist/types.d.ts",
+            },
+        },
+        imports: {
+            "#db/*": {
+                source: "./src/*.ts",
+                types: "./dist/*.d.ts",
+                default: "./dist/*.js",
             },
         },
-        imports: { "#db/*": { default: "./src/*.ts", types: "./src/*.ts" } },
     };
     return {
         definition: db,
         exposure,
         manifest: {
             name: db.name,
-            version: "0.0.0",
             private: true,
             type: "module",
+            files: ["dist"],
             ...exposure,
             scripts: databaseScripts(),
             dependencies: { "drizzle-orm": "catalog:" },
@@ -375,22 +377,38 @@ function databaseContribution(context) {
                 oxlint: "catalog:",
                 "oxlint-tsgolint": "catalog:",
                 "typescript-7": "catalog:",
+                vite: "catalog:",
                 vitest: "catalog:",
             },
             engines: { node: context.toolchain.nodeLtsMajor },
         },
         operations: [
-            { kind: "writeJson", to: `${db.path}/package.json`, value: {} },
+            {
+                kind: "writeJson",
+                to: `${db.path}/package.json`,
+                value: {},
+                multilineArrays: ["files"],
+            },
             ...copyOperations(context, db.path, sourceFiles),
         ],
         environmentNeeds: [],
-        foundation: foundation(),
+        foundation: {
+            ...foundation(packageDefinitions),
+            databasePreparation: {
+                kind: "sqlite-database-preparation",
+                migrationPackageName: migrations.name,
+                consumers: [
+                    { kind: "application-dev", packageName: web.name },
+                    { kind: "database-test", packageName: db.name },
+                    { kind: "application-e2e", packageName: web.name },
+                ],
+            },
+        },
     };
 }
-function migrationsContribution(context) {
-    const { db, migrations } = definitions(context);
+function migrationsContribution(context, packageDefinitions = definitions(context)) {
+    const { db, migrations } = packageDefinitions;
     const sourceFiles = [
-        "db-migrations/drizzle.config.ts",
         "db-migrations/tsconfig.json",
         "db-migrations/tsconfig.build.json",
         "db-migrations/drizzle/migrations/20260709120325_old_captain_flint/migration.sql",
@@ -402,11 +420,10 @@ function migrationsContribution(context) {
         exposure: { exports: {}, imports: {} },
         manifest: {
             name: migrations.name,
-            version: "0.0.0",
             private: true,
             type: "module",
             files: ["drizzle.config.ts", "drizzle/migrations"],
-            scripts: migrationScripts(db.name),
+            scripts: migrationScripts(),
             dependencies: { "drizzle-kit": "catalog:", "drizzle-orm": "catalog:" },
             devDependencies: {
                 "@types/node": "catalog:",
@@ -425,39 +442,70 @@ function migrationsContribution(context) {
                 multilineArrays: ["files"],
             },
             ...copyOperations(context, migrations.path, sourceFiles),
+            {
+                kind: "writeTextTemplate",
+                source: templateSources.vikeApp,
+                from: "db-migrations/drizzle.config.ts",
+                to: `${migrations.path}/drizzle.config.ts`,
+                replacements: { DB_PACKAGE_NAME: db.name },
+            },
         ],
         environmentNeeds: [],
-        foundation: foundation(),
+        foundation: foundation(packageDefinitions),
     };
 }
-export const vikeAppDefinition = {
-    metadata: {
-        name: "vike-app",
-        title: "Vike app",
-        description: "Vike, Hono, Telefunc, Drizzle, and Vue workspace with separate database and migration packages.",
-    },
-    source: templateSources.vikeApp,
-    plannerSourceFile: fileURLToPath(import.meta.url),
-    blueprint(context) {
-        const { web, db, migrations } = definitions(context);
-        return {
-            schemaVersion: 2,
-            packages: [web, db, migrations],
-            packageLinkIntents: [
-                { consumerPackagePath: web.path, providerPackagePath: db.path },
-                {
-                    consumerPackagePath: migrations.path,
-                    providerPackagePath: db.path,
-                },
-            ],
-        };
-    },
-    planInitialization: webContribution,
-    planInitializationContributions(context) {
-        return [
-            webContribution(context),
-            databaseContribution(context),
-            migrationsContribution(context),
-        ];
-    },
-};
+const webReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "web",
+    replay: ({ context, initialPackages }) => webContribution(context, replayDefinitions(initialPackages)),
+});
+const databaseReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "database",
+    replay: ({ context, initialPackages }) => databaseContribution(context, replayDefinitions(initialPackages)),
+});
+const migrationsReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "migrations",
+    replay: ({ context, initialPackages }) => migrationsContribution(context, replayDefinitions(initialPackages)),
+});
+export function createVikeAppDefinition(resolvePackageDefinitions = definitions) {
+    return {
+        metadata: {
+            name: "vike-app",
+            title: "Vike 应用",
+            description: "包含独立数据库和迁移包的 Vike、Hono、Telefunc、Drizzle 与 Vue 工作区。",
+        },
+        source: templateSources.vikeApp,
+        plannerSourceFile: fileURLToPath(import.meta.url),
+        packageContributionReplayAdapters: [
+            webReplayAdapter,
+            databaseReplayAdapter,
+            migrationsReplayAdapter,
+        ],
+        blueprint(context) {
+            const { web, db, migrations } = resolvePackageDefinitions(context);
+            return {
+                schemaVersion: 3,
+                packages: [web, db, migrations],
+                packageLinkIntents: [
+                    { consumerPackagePath: web.path, providerPackagePath: db.path },
+                    {
+                        consumerPackagePath: migrations.path,
+                        providerPackagePath: db.path,
+                    },
+                ],
+            };
+        },
+        planInitialization(context) {
+            const packageDefinitions = resolvePackageDefinitions(context);
+            return webReplayAdapter.identify(webContribution(context, packageDefinitions));
+        },
+        planInitializationContributions(context) {
+            const packageDefinitions = resolvePackageDefinitions(context);
+            return [
+                webReplayAdapter.identify(webContribution(context, packageDefinitions)),
+                databaseReplayAdapter.identify(databaseContribution(context, packageDefinitions)),
+                migrationsReplayAdapter.identify(migrationsContribution(context, packageDefinitions)),
+            ];
+        },
+    };
+}
+export const vikeAppDefinition = createVikeAppDefinition();

package/node_modules/@ykdz/template-builtin-presets/dist/src/vue-app/definition.d.ts

@@ -1,2 +1,26 @@
-import type { BuiltInPresetDefinition } from "#template-core/preset-definition";
-export declare const vueAppDefinition: BuiltInPresetDefinition;
+import { type GenerationContext } from "@ykdz/template-core/preset-definition";
+import type { PackageDefinition } from "@ykdz/template-core/project-blueprint";
+export declare const vueAppDefinition: {
+    metadata: {
+        name: string;
+        title: string;
+        description: string;
+    };
+    source: import("@ykdz/template-core/renderer").TemplateSourceHandle;
+    plannerSourceFile: string;
+    packageContributionReplayAdapters: import("@ykdz/template-core/preset-definition").PackageContributionReplayAdapter[];
+    blueprint(context: GenerationContext): {
+        schemaVersion: 3;
+        packages: PackageDefinition[];
+    };
+    planInitialization(context: GenerationContext): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+    defaultPackagePath({ packageLeafName }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+    }): string;
+    planPackageAddition({ context, packageLeafName, packagePath }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+        readonly packagePath: string;
+    }): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+};

package/node_modules/@ykdz/template-builtin-presets/dist/src/vue-app/definition.js

@@ -1,3 +1,4 @@
+import { definePackageContributionReplayAdapter, } from "@ykdz/template-core/preset-definition";
 import { sharedVueSourceOperations, vueApplicationDevelopmentContainerToolLayers, vueApplicationEnvironmentNeeds, vueApplicationExposure, vueApplicationManifest, vueApplicationScripts, } from "../shared/vue.js";
 import { templateSources } from "../template-sources.js";
 function packageScripts() {
@@ -7,8 +8,8 @@ function packageScripts() {
     };
 }
 function appContribution(options) {
-    const definition = {
-        name: `@${options.context.scope}/${options.packageLeafName}`,
+    const definition = options.packageDefinition ?? {
+        name: `@${options.context.defaultPackageScope}/${options.packageLeafName}`,
         path: options.packagePath,
         role: "runtime-service",
     };
@@ -52,26 +53,37 @@ function appContribution(options) {
         foundation: {
             toolchains: {},
             editorCapabilities: ["oxc-format-lint", "vue", "tailwind", "vitest"],
+            typescriptConfigurationPackage: { dependency: "required" },
             dependencyMaintenance: {
                 ecosystems: ["npm", "github-actions", "docker"],
                 interval: "weekly",
             },
-            workspacePackageGlobs: [`${options.packagePath.split("/")[0]}/*`],
+            workspacePackageGlobs: [`${definition.path.split("/")[0]}/*`],
             developmentContainerToolLayers: vueApplicationDevelopmentContainerToolLayers(),
         },
     };
 }
+const appReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "app",
+    replay: ({ context, packageDefinition, packageLeafName }) => appContribution({
+        context,
+        packageLeafName,
+        packagePath: packageDefinition.path,
+        packageDefinition,
+    }),
+});
 export const vueAppDefinition = {
     metadata: {
         name: "vue-app",
-        title: "Vue app",
-        description: "Vue app workspace with Vite, Tailwind, Pinia, and test tooling.",
+        title: "Vue 应用",
+        description: "使用 Vite、Tailwind、Pinia 和测试工具的 Vue 应用工作区。",
     },
     source: templateSources.vueApp,
     plannerSourceFile: fileURLToPath(import.meta.url),
+    packageContributionReplayAdapters: [appReplayAdapter],
     blueprint(context) {
         return {
-            schemaVersion: 2,
+            schemaVersion: 3,
             packages: [
                 appContribution({
                     context,
@@ -82,17 +94,17 @@ export const vueAppDefinition = {
         };
     },
     planInitialization(context) {
-        return appContribution({
+        return appReplayAdapter.identify(appContribution({
             context,
             packageLeafName: "web",
             packagePath: "apps/web",
-        });
+        }));
     },
     defaultPackagePath({ packageLeafName }) {
         return `apps/${packageLeafName}`;
     },
     planPackageAddition({ context, packageLeafName, packagePath }) {
-        return appContribution({ context, packageLeafName, packagePath });
+        return appReplayAdapter.identify(appContribution({ context, packageLeafName, packagePath }));
     },
 };
 import { fileURLToPath } from "node:url";

package/node_modules/@ykdz/template-builtin-presets/dist/src/vue-hono-app/definition.d.ts

@@ -1,2 +1,22 @@
-import type { BuiltInPresetDefinition } from "#template-core/preset-definition";
-export declare const vueHonoAppDefinition: BuiltInPresetDefinition;
+import { type GenerationContext } from "@ykdz/template-core/preset-definition";
+import type { PackageDefinition } from "@ykdz/template-core/project-blueprint";
+export declare const vueHonoAppDefinition: {
+    metadata: {
+        name: string;
+        title: string;
+        description: string;
+    };
+    source: import("@ykdz/template-core/renderer").TemplateSourceHandle;
+    plannerSourceFile: string;
+    packageContributionReplayAdapters: import("@ykdz/template-core/preset-definition").PackageContributionReplayAdapter[];
+    blueprint(context: GenerationContext): {
+        schemaVersion: 3;
+        packages: PackageDefinition[];
+        packageLinkIntents: {
+            consumerPackagePath: string;
+            providerPackagePath: string;
+        }[];
+    };
+    planInitialization(context: GenerationContext): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+    planInitializationContributions(context: GenerationContext): import("@ykdz/template-core/preset-definition").PlannedPackageContribution[];
+};