@ykdz/template 0.0.7 → 0.0.9

package/node_modules/@ykdz/template-builtin-source/dist/templates/vue-app/projection.js

@@ -0,0 +1,372 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject, } from "@ykdz/template-core/renderer";
+export const vueAppPresetMetadata = {
+    name: "vue-app",
+    title: "Vue app",
+    description: "Vue app workspace with Vite, Tailwind, Pinia, and test tooling.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Supported,
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const webPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+function planVueAppPackageChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: webPackageBoundary },
+            { kind: "oxc-lint", owner: webPackageBoundary },
+            { kind: "typescript-typecheck", owner: webPackageBoundary },
+            { kind: "build", owner: webPackageBoundary },
+            { kind: "unit-test", owner: webPackageBoundary },
+            { kind: "e2e-test", owner: webPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planVueAppPackageFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: webPackageBoundary },
+            { kind: "oxc-lint-fix", owner: webPackageBoundary },
+        ],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function scopedPackageName(packageScope) {
+    return `@${packageScope}/web`;
+}
+export function vueAppBlueprint(options = { targetDir: process.cwd() }) {
+    const packageScope = packageScopeFromOptions(options);
+    return {
+        schemaVersion: 1,
+        preset: "vue-app",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...vueAppPresetMetadata.features],
+        packages: [{ name: scopedPackageName(packageScope), path: "apps/web" }],
+    };
+}
+export function projectVueAppPackageScripts() {
+    return {
+        build: "vite build",
+        check: renderRootCheckCommand(planVueAppPackageChecks()),
+        dev: "vite",
+        fix: renderFixCommand(planVueAppPackageFixes()),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts .",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix",
+        preview: "vite preview",
+        test: "vitest run",
+        "test:e2e": "pnpm run build && playwright test",
+        typecheck: "vue-tsc --build --noEmit",
+    };
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function localPortsFromText(text) {
+    return [
+        ...text.matchAll(/port:\s*(\d+)/g),
+        ...text.matchAll(/--port\s+(\d+)/g),
+        ...text.matchAll(/https?:\/\/(?:localhost|127\.0\.0\.1):(\d+)/g),
+    ].map((match) => Number(match[1]));
+}
+async function usedPlaywrightPorts(root, blueprint) {
+    const ports = new Set();
+    for (const projectPackage of blueprint.packages ?? []) {
+        try {
+            const configText = await readFile(path.join(root, projectPackage.path, "playwright.config.ts"), "utf8");
+            for (const port of localPortsFromText(configText)) {
+                ports.add(port);
+            }
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return ports;
+}
+async function nextVuePreviewPort(root, blueprint) {
+    const usedPorts = await usedPlaywrightPorts(root, blueprint);
+    let port = 4173;
+    while (usedPorts.has(port)) {
+        port += 1;
+    }
+    return port;
+}
+function vueAppPlaywrightConfig(previewPort) {
+    return `import { defineConfig, devices } from "@playwright/test";
+
+const previewUrl = "http://127.0.0.1:${previewPort}";
+
+export default defineConfig({
+  testDir: "./test/e2e",
+  use: {
+    baseURL: previewUrl,
+    trace: "on-first-retry"
+  },
+  webServer: {
+    command: "pnpm run preview --host 127.0.0.1 --port ${previewPort}",
+    reuseExistingServer: !process.env.CI,
+    url: previewUrl
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] }
+    }
+  ]
+});
+`;
+}
+function packageAdditionOperations(packagePath, packageNameValue, nodeVersion) {
+    return [
+        {
+            kind: "writeJson",
+            to: `${packagePath}/package.json`,
+            value: {
+                name: packageNameValue,
+                version: "0.0.0",
+                private: true,
+                type: "module",
+                imports: {
+                    "#/*": {
+                        default: "./src/*.ts",
+                        types: "./src/*.ts",
+                    },
+                },
+                scripts: projectVueAppPackageScripts(),
+                dependencies: {
+                    "@vueuse/core": "catalog:",
+                    pinia: "catalog:",
+                    vue: "catalog:",
+                },
+                devDependencies: {
+                    "@playwright/test": "catalog:",
+                    "@tailwindcss/vite": "catalog:",
+                    "@types/node": "catalog:",
+                    "@types/web-bluetooth": "catalog:",
+                    "@vitejs/plugin-vue": "catalog:",
+                    "@vue/tsconfig": "catalog:",
+                    oxfmt: "catalog:",
+                    oxlint: "catalog:",
+                    "oxlint-tsgolint": "catalog:",
+                    tailwindcss: "catalog:",
+                    typescript: "catalog:",
+                    vite: "catalog:",
+                    vitest: "catalog:",
+                    "vue-tsc": "catalog:",
+                },
+                engines: {
+                    node: nodeVersion,
+                },
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.json`,
+            value: {
+                files: [],
+                references: [
+                    { path: "./tsconfig.app.json" },
+                    { path: "./tsconfig.test.json" },
+                    { path: "./tsconfig.node.json" },
+                ],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.app.json`,
+            value: {
+                extends: "@vue/tsconfig/tsconfig.dom.json",
+                compilerOptions: {
+                    composite: true,
+                    erasableSyntaxOnly: true,
+                    exactOptionalPropertyTypes: true,
+                    forceConsistentCasingInFileNames: true,
+                    isolatedModules: true,
+                    module: "ESNext",
+                    moduleResolution: "Bundler",
+                    noEmitOnError: true,
+                    noFallthroughCasesInSwitch: true,
+                    noImplicitOverride: true,
+                    noImplicitReturns: true,
+                    noUncheckedIndexedAccess: true,
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "es2023",
+                    tsBuildInfoFile: "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+                    types: ["web-bluetooth"],
+                    verbatimModuleSyntax: true,
+                },
+                include: ["env.d.ts", "src/**/*.ts", "src/**/*.vue"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.test.json`,
+            value: {
+                extends: "./tsconfig.app.json",
+                compilerOptions: {
+                    lib: ["ESNext", "DOM", "DOM.Iterable"],
+                    tsBuildInfoFile: "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
+                    types: ["node", "vitest/globals", "web-bluetooth"],
+                },
+                include: ["env.d.ts", "src/**/*.ts", "src/**/*.vue", "test/**/*.ts"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.node.json`,
+            value: {
+                compilerOptions: {
+                    composite: true,
+                    erasableSyntaxOnly: true,
+                    exactOptionalPropertyTypes: true,
+                    forceConsistentCasingInFileNames: true,
+                    isolatedModules: true,
+                    module: "ESNext",
+                    moduleResolution: "Bundler",
+                    noEmitOnError: true,
+                    lib: ["ESNext", "DOM", "DOM.Iterable"],
+                    noFallthroughCasesInSwitch: true,
+                    noImplicitOverride: true,
+                    noImplicitReturns: true,
+                    noUncheckedIndexedAccess: true,
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "es2023",
+                    tsBuildInfoFile: "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+                    types: ["node"],
+                    verbatimModuleSyntax: true,
+                },
+                include: ["playwright.config.ts", "vite.config.ts", "vitest.config.ts"],
+            },
+        },
+        { kind: "copyFile", from: "env.d.ts", to: `${packagePath}/env.d.ts` },
+        { kind: "copyFile", from: "index.html", to: `${packagePath}/index.html` },
+        {
+            kind: "copyFile",
+            from: "playwright.config.ts",
+            to: `${packagePath}/playwright.config.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "vite.config.ts",
+            to: `${packagePath}/vite.config.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "vitest.config.ts",
+            to: `${packagePath}/vitest.config.ts`,
+        },
+        { kind: "copyFile", from: "src/App.vue", to: `${packagePath}/src/App.vue` },
+        { kind: "copyFile", from: "src/main.ts", to: `${packagePath}/src/main.ts` },
+        {
+            kind: "copyFile",
+            from: "src/style.css",
+            to: `${packagePath}/src/style.css`,
+        },
+        {
+            kind: "copyFile",
+            from: "src/stores/counter.ts",
+            to: `${packagePath}/src/stores/counter.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "test/app.test.ts",
+            to: `${packagePath}/test/app.test.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "test/e2e/app.spec.ts",
+            to: `${packagePath}/test/e2e/app.spec.ts`,
+        },
+    ];
+}
+async function packageAdditionPlan({ root, blueprint, packageName: packageNameValue, packagePath, nodeVersion, }) {
+    const [workspaceCollection] = packagePath.split("/");
+    const previewPort = await nextVuePreviewPort(root, blueprint);
+    return {
+        packagePath,
+        workspacePackageGlob: `${workspaceCollection}/*`,
+        packageRole: "runtime-service",
+        packageSourcePreset: "vue-app",
+        sourceRoot: templateSourceRoot(),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+        operations: packageAdditionOperations(packagePath, packageNameValue, nodeVersion),
+        textFiles: [
+            {
+                path: `${packagePath}/playwright.config.ts`,
+                text: vueAppPlaywrightConfig(previewPort),
+            },
+        ],
+    };
+}
+function templateSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedTemplateRoot = path.join(projectionDir, "..", "..", "..", "templates", "vue-app");
+    return existsSync(path.join(publishedTemplateRoot, "src", "App.vue"))
+        ? publishedTemplateRoot
+        : projectionDir;
+}
+function sharedOxcSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedSharedRoot = path.join(projectionDir, "..", "..", "..", "templates", "shared", "oxc");
+    return existsSync(path.join(publishedSharedRoot, "oxfmt.config.ts"))
+        ? publishedSharedRoot
+        : path.join(projectionDir, "..", "shared", "oxc");
+}
+export const vueAppPresetProjection = {
+    metadata: vueAppPresetMetadata,
+    capabilities: {
+        packageAddition: {
+            planPackageAddition: packageAdditionPlan,
+        },
+    },
+    blueprint: vueAppBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: vueAppPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("vue-app"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/dist/templates/vue-hono-app/projection.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltInPreset, ProjectBlueprint } from "@ykdz/template-core/declarations";
+import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare const vueHonoAppPresetMetadata: BuiltInPreset;
+export declare function vueHonoAppBlueprint(options: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectVueHonoRootPackageScripts(): Record<string, string>;
+export declare function projectVueHonoApiPackageScripts(): Record<string, string>;
+export declare function projectVueHonoWebPackageScripts(): Record<string, string>;
+export declare const vueHonoAppPresetProjection: PresetProjection;

package/node_modules/@ykdz/template-builtin-source/dist/templates/vue-hono-app/projection.js

@@ -0,0 +1,203 @@
+import path from "node:path";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject } from "@ykdz/template-core/renderer";
+export const vueHonoAppPresetMetadata = {
+    name: "vue-hono-app",
+    title: "Vue Hono app",
+    description: "Full-stack Vue and Hono workspace with Hono RPC typing.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Unsupported,
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const rootBoundary = {
+    kind: "workspace-orchestration",
+    path: ".",
+};
+const apiPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const webPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const workspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "apps/*",
+};
+const webWorkspaceBoundary = {
+    kind: "package-boundary",
+    path: "apps/web",
+};
+function honoApiCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+    ];
+}
+function vueWebCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+        { kind: "e2e-test", owner },
+    ];
+}
+function nodeFixComponents(owner) {
+    return [
+        { kind: "oxc-format-write", owner },
+        { kind: "oxc-lint-fix", owner },
+    ];
+}
+function planVueHonoRootChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: rootBoundary },
+            { kind: "oxc-lint", owner: rootBoundary },
+            { kind: "typescript-typecheck", owner: rootBoundary },
+            { kind: "turbo-package-typecheck", owner: workspacePackageBoundary },
+            { kind: "turbo-package-build", owner: workspacePackageBoundary },
+            { kind: "turbo-package-test", owner: workspacePackageBoundary },
+            { kind: "turbo-package-e2e-test", owner: workspacePackageBoundary },
+            { kind: "turbo-package-check", owner: workspacePackageBoundary },
+        ],
+        environmentNeeds: [
+            {
+                kind: "playwright-browser-assets",
+                browser: "chromium",
+                owner: webWorkspaceBoundary,
+            },
+        ],
+    };
+}
+function planVueHonoRootFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: rootBoundary },
+            { kind: "oxc-lint-fix", owner: rootBoundary },
+            { kind: "turbo-package-fix", owner: workspacePackageBoundary },
+        ],
+    };
+}
+function planVueHonoApiChecks() {
+    return {
+        components: [...honoApiCheckComponents(apiPackageBoundary)],
+        environmentNeeds: [],
+    };
+}
+function planVueHonoWebChecks() {
+    return {
+        components: [...vueWebCheckComponents(webPackageBoundary)],
+        environmentNeeds: [],
+    };
+}
+function planVueHonoPackageFixes(owner) {
+    return {
+        components: [...nodeFixComponents(owner)],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function scopedPackageName(packageScope, leaf) {
+    return `@${packageScope}/${leaf}`;
+}
+export function vueHonoAppBlueprint(options) {
+    const packageScope = packageScopeFromOptions(options);
+    return {
+        schemaVersion: 1,
+        preset: "vue-hono-app",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...vueHonoAppPresetMetadata.features],
+        packages: [
+            { name: scopedPackageName(packageScope, "web"), path: "apps/web" },
+            { name: scopedPackageName(packageScope, "api"), path: "apps/api" },
+        ],
+    };
+}
+export function projectVueHonoRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planVueHonoRootChecks()),
+        dev: "turbo run dev --parallel",
+        fix: renderFixCommand(planVueHonoRootFixes()),
+        "format:check": "oxfmt --check --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        "format:write": "oxfmt --write --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        lint: "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts",
+        "lint:fix": "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix",
+        typecheck: "tsc -p tsconfig.config.json --noEmit",
+    };
+}
+export function projectVueHonoApiPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+        check: renderRootCheckCommand(planVueHonoApiChecks()),
+        dev: "tsx watch src/server.ts",
+        fix: renderFixCommand(planVueHonoPackageFixes(apiPackageBoundary)),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts .",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix",
+        start: "node dist/server.js",
+        test: "vitest run",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
+export function projectVueHonoWebPackageScripts() {
+    return {
+        build: "vite build",
+        check: renderRootCheckCommand(planVueHonoWebChecks()),
+        dev: "vite",
+        fix: renderFixCommand(planVueHonoPackageFixes(webPackageBoundary)),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts .",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix",
+        preview: "vite preview",
+        test: "vitest run",
+        "test:e2e": "pnpm run build && playwright test",
+        typecheck: "vue-tsc --build",
+    };
+}
+export const vueHonoAppPresetProjection = {
+    metadata: vueHonoAppPresetMetadata,
+    blueprint: vueHonoAppBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: vueHonoAppPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("vue-hono-app"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@ykdz/template-builtin-source",
+  "version": "0.0.9",
+  "private": true,
+  "files": [
+    "dist",
+    "templates",
+    "!templates/*.tmp",
+    "!templates/registry.ts",
+    "!templates/projection-plans.ts",
+    "!templates/*/projection.ts",
+    "!templates/shared/oxc/tsconfig.json",
+    "!templates/**/node_modules"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./registry": {
+      "types": "./dist/templates/registry.d.ts",
+      "default": "./dist/templates/registry.js"
+    },
+    "./projection-plans": {
+      "types": "./dist/templates/projection-plans.d.ts",
+      "default": "./dist/templates/projection-plans.js"
+    },
+    "./templates/*": {
+      "types": "./dist/templates/*.d.ts",
+      "default": "./dist/templates/*.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check:templates": "pnpm run check:templates:shared-oxc && pnpm run check:templates:static-source",
+    "check:templates:shared-oxc": "pnpm run check:templates:shared-oxc:format && pnpm run check:templates:shared-oxc:lint && pnpm run check:templates:shared-oxc:typecheck",
+    "check:templates:shared-oxc:format": "oxfmt --check templates/shared/oxc",
+    "check:templates:shared-oxc:lint": "oxlint --config templates/shared/oxc/node/oxlint.config.ts templates/shared/oxc",
+    "check:templates:shared-oxc:typecheck": "tsc -p templates/shared/oxc/tsconfig.json --noEmit",
+    "check:templates:static-source": "rustup run stable rustfmt --check templates/rust-bin/src/main.rs",
+    "format:check": "oxfmt --check --config ../../oxfmt.config.ts --ignore-path ../../.oxfmtignore .",
+    "format:write": "oxfmt --write --config ../../oxfmt.config.ts --ignore-path ../../.oxfmtignore .",
+    "lint": "oxlint --config ../../oxlint.config.ts src templates/projection-plans.ts templates/registry.ts templates/*/projection.ts",
+    "lint:fix": "oxlint --config ../../oxlint.config.ts src templates/projection-plans.ts templates/registry.ts templates/*/projection.ts --fix",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@ykdz/template-core": "workspace:*",
+    "typescript": "catalog:",
+    "valibot": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "oxfmt": "catalog:",
+    "oxlint": "catalog:",
+    "oxlint-tsgolint": "catalog:"
+  }
+}