zudojs-cli 2.0.0 → 2.1.0

package/dist/src/recipes/docker/docker.compose.js

@@ -0,0 +1,90 @@
+/**
+ * zudojs-cli — `compose.yaml` for `zudojs add docker`.
+ *
+ * One service per backend app plus one per enabled integration that needs
+ * a server: `postgres` (database), `redis` and `mailpit` (email, SMTP on
+ * 1025, web UI on 8025). Backing services publish on 127.0.0.1 only, and
+ * the Postgres password is read from `.env` (POSTGRES_PASSWORD): compose
+ * refuses to start without it, so no credential is written into the file.
+ */
+/**
+ * Whether compose runs a `postgres` service. The `database` capability is
+ * recorded for MySQL and SQLite projects too, which used to get a Postgres
+ * container and a DATABASE_URL overriding their own.
+ */
+export function usesPostgres(context) {
+    return context.features.has("database") && context.database === "postgresql";
+}
+const POSTGRES_URL = (db) => `postgresql://postgres:\${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${db}`;
+function appService(context, app) {
+    const env = [
+        `      NODE_ENV: production`,
+        `      HOST: 0.0.0.0`,
+        `      PORT: "${app.port}"`,
+        ...(usesPostgres(context) ? [`      DATABASE_URL: ${POSTGRES_URL(context.projectSlug)}`] : []),
+        ...(context.features.has("redis") ? [`      REDIS_URL: redis://redis:6379`] : []),
+        ...(context.features.has("email") ? [`      SMTP_HOST: mailpit`, `      SMTP_PORT: "1025"`] : []),
+    ];
+    const dependsOn = [
+        ...(usesPostgres(context) ? ["postgres"] : []),
+        ...(context.features.has("redis") ? ["redis"] : []),
+    ];
+    const dockerfile = app.dir === "" ? "Dockerfile" : `${app.dir}/Dockerfile`;
+    return `  ${app.name}:
+    build:
+      context: .
+      dockerfile: ${dockerfile}
+    ports:
+      - "${app.port}:${app.port}"
+    env_file:
+      - path: ${app.dir === "" ? "" : `${app.dir}/`}.env
+        required: false
+    environment:
+${env.join("\n")}
+${dependsOn.length === 0 ? "" : `    depends_on:\n${dependsOn.map((name) => `      ${name}:\n        condition: service_healthy`).join("\n")}\n`}`;
+}
+const BACKING_SERVICES = {
+    database: (db) => `  postgres:
+    image: postgres:17-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
+      POSTGRES_DB: ${db}
+    ports:
+      - "127.0.0.1:5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d ${db}"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+`,
+    redis: () => `  redis:
+    image: redis:8-alpine
+    ports:
+      - "127.0.0.1:6379:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+`,
+    email: () => `  mailpit:
+    image: axllent/mailpit:v1.27
+    ports:
+      - "127.0.0.1:1025:1025"
+      - "127.0.0.1:8025:8025"
+`,
+};
+/** Renders `compose.yaml`. */
+export function renderComposeFile(context) {
+    const backing = Object.entries(BACKING_SERVICES)
+        .filter(([feature]) => (feature === "database" ? usesPostgres(context) : context.features.has(feature)))
+        .map(([, render]) => render(context.projectSlug));
+    const volumes = usesPostgres(context) ? "\nvolumes:\n  postgres-data:\n" : "";
+    return `# docker compose up --build
+services:
+${[...context.apps.map((app) => appService(context, app)), ...backing].join("\n")}${volumes}`;
+}
+//# sourceMappingURL=docker.compose.js.map

package/dist/src/recipes/docker/docker.recipe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * zudojs-cli — `zudojs add docker`: a multi-stage, non-root Node 24
+ * Dockerfile per backend app, `.dockerignore`, and `compose.yaml` with a
+ * service per app and per enabled integration (postgres, redis, mailpit).
+ * Existing files are kept: a project that already has a compose file
+ * (microservice projects are created with docker-compose.yml) keeps it.
+ */
+import type { ProjectRecipe } from "../recipe.type.js";
+export declare const dockerRecipe: ProjectRecipe;
+//# sourceMappingURL=docker.recipe.d.ts.map

package/dist/src/recipes/docker/docker.recipe.js

@@ -0,0 +1,51 @@
+/**
+ * zudojs-cli — `zudojs add docker`: a multi-stage, non-root Node 24
+ * Dockerfile per backend app, `.dockerignore`, and `compose.yaml` with a
+ * service per app and per enabled integration (postgres, redis, mailpit).
+ * Existing files are kept: a project that already has a compose file
+ * (microservice projects are created with docker-compose.yml) keeps it.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile.template.js";
+import { renderComposeFile, usesPostgres } from "./docker.compose.js";
+const DOCKERIGNORE = `node_modules
+**/node_modules
+dist
+**/dist
+.git
+.env
+**/.env
+*.log
+.data
+**/src/generated
+`;
+export const dockerRecipe = {
+    scope: "project",
+    feature: "docker",
+    summary: "Dockerfile (multi-stage, non-root, Node 24), .dockerignore and compose.yaml",
+    files: (context) => {
+        const files = { ".dockerignore": DOCKERIGNORE };
+        for (const app of context.apps) {
+            files[app.dir === "" ? "Dockerfile" : `${app.dir}/Dockerfile`] = renderAppPackageDockerfile({
+                appPath: app.dir === "" ? "." : app.dir,
+                port: app.port,
+                packageManager: context.packageManager,
+                prisma: app.prisma,
+            });
+        }
+        const hasCompose = ["compose.yaml", "compose.yml", "docker-compose.yml", "docker-compose.yaml"]
+            .some((name) => existsSync(join(context.root, name)));
+        if (!hasCompose)
+            files["compose.yaml"] = renderComposeFile(context);
+        return files;
+    },
+    // Empty, never a placeholder: compose refuses to start until it is set,
+    // so a copied .env.example cannot ship a guessable password. Hex keeps it
+    // valid inside DATABASE_URL.
+    env: (context) => usesPostgres(context)
+        ? [{ name: "POSTGRES_PASSWORD", value: "", comment: "Password for the compose.yaml postgres service; generate with: openssl rand -hex 32" }]
+        : [],
+    nextSteps: () => ["cp .env.example .env, then: docker compose up --build"],
+};
+//# sourceMappingURL=docker.recipe.js.map

package/dist/src/recipes/docker/docker.refresh.d.ts

@@ -0,0 +1,13 @@
+/**
+ * zudojs-cli — Keeping CLI-written Dockerfiles in step with the app.
+ *
+ * A Dockerfile the CLI wrote for an app without Prisma cannot build it once
+ * `zudojs add database` has run (the schema is needed before `prisma
+ * generate`). A Dockerfile is rewritten only when it is byte-for-byte what
+ * the CLI rendered for the other Prisma setting, so a hand-edited file is
+ * never touched.
+ */
+import type { ProjectRecipeContext } from "../recipe.type.js";
+/** Rewrites unedited CLI Dockerfiles whose Prisma setting is stale; returns their paths. */
+export declare function refreshGeneratedDockerfiles(context: ProjectRecipeContext): Promise<readonly string[]>;
+//# sourceMappingURL=docker.refresh.d.ts.map

package/dist/src/recipes/docker/docker.refresh.js

@@ -0,0 +1,37 @@
+/**
+ * zudojs-cli — Keeping CLI-written Dockerfiles in step with the app.
+ *
+ * A Dockerfile the CLI wrote for an app without Prisma cannot build it once
+ * `zudojs add database` has run (the schema is needed before `prisma
+ * generate`). A Dockerfile is rewritten only when it is byte-for-byte what
+ * the CLI rendered for the other Prisma setting, so a hand-edited file is
+ * never touched.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile.template.js";
+import { writeFile } from "../../utils/utils.fileSystem.js";
+/** Rewrites unedited CLI Dockerfiles whose Prisma setting is stale; returns their paths. */
+export async function refreshGeneratedDockerfiles(context) {
+    const refreshed = [];
+    for (const app of context.apps) {
+        const path = app.dir === "" ? "Dockerfile" : `${app.dir}/Dockerfile`;
+        const fullPath = join(context.root, path);
+        if (!existsSync(fullPath))
+            continue;
+        const render = (prisma) => renderAppPackageDockerfile({
+            appPath: app.dir === "" ? "." : app.dir,
+            port: app.port,
+            packageManager: context.packageManager,
+            prisma,
+        });
+        const current = readFileSync(fullPath, "utf-8");
+        const wanted = render(app.prisma);
+        if (current !== wanted && current === render(!app.prisma)) {
+            await writeFile(context.root, path, wanted);
+            refreshed.push(path);
+        }
+    }
+    return refreshed;
+}
+//# sourceMappingURL=docker.refresh.js.map

package/dist/src/recipes/docker/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * zudojs-cli — The docker project recipe.
+ */
+export { dockerRecipe } from "./docker.recipe.js";
+export { renderComposeFile } from "./docker.compose.js";
+export { refreshGeneratedDockerfiles } from "./docker.refresh.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/recipes/docker/index.js

@@ -0,0 +1,7 @@
+/**
+ * zudojs-cli — The docker project recipe.
+ */
+export { dockerRecipe } from "./docker.recipe.js";
+export { renderComposeFile } from "./docker.compose.js";
+export { refreshGeneratedDockerfiles } from "./docker.refresh.js";
+//# sourceMappingURL=index.js.map

package/dist/src/recipes/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Feature recipes for `zudojs add`.
+ */
+export * from "./recipe.type.js";
+export * from "./recipe.registry.js";
+export { refreshGeneratedDockerfiles } from "./docker/index.js";
+export * from "./apply/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/recipes/index.js

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Feature recipes for `zudojs add`.
+ */
+export * from "./recipe.type.js";
+export * from "./recipe.registry.js";
+export { refreshGeneratedDockerfiles } from "./docker/index.js";
+export * from "./apply/index.js";
+//# sourceMappingURL=index.js.map

package/dist/src/recipes/recipe.registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * zudojs-cli — The recipe behind every feature `zudojs add` accepts.
+ *
+ * Kept in step with `FEATURE_PACKAGES` by `tests/addRecipes.test.ts`: a
+ * feature name without a recipe would install a package and write nothing,
+ * which is exactly what `add` used to do.
+ */
+import type { FeatureRecipe } from "./recipe.type.js";
+/** Every recipe, keyed by feature. */
+export declare const FEATURE_RECIPES: Readonly<Record<string, FeatureRecipe>>;
+/**
+ * Resolves a feature name (or alias) to its recipe.
+ *
+ * @throws {CLIValidationError} For refused or unknown names.
+ */
+export declare function resolveFeatureRecipe(name: string): FeatureRecipe;
+//# sourceMappingURL=recipe.registry.d.ts.map

package/dist/src/recipes/recipe.registry.js

@@ -0,0 +1,46 @@
+/**
+ * zudojs-cli — The recipe behind every feature `zudojs add` accepts.
+ *
+ * Kept in step with `FEATURE_PACKAGES` by `tests/addRecipes.test.ts`: a
+ * feature name without a recipe would install a package and write nothing,
+ * which is exactly what `add` used to do.
+ */
+import { FEATURE_ALIASES, FEATURE_PACKAGES, FEATURE_REFUSALS, } from "../constants/index.js";
+import { CLIValidationError } from "../errors/index.js";
+import { cacheRecipe, databaseRecipe, emailRecipe, messagingRecipe, observabilityRecipe, openapiRecipe, queueRecipe, redisRecipe, schedulerRecipe, storageRecipe, websocketsRecipe, } from "./catalog/index.js";
+import { dockerRecipe } from "./docker/index.js";
+/** Every recipe, keyed by feature. */
+export const FEATURE_RECIPES = Object.freeze({
+    database: databaseRecipe,
+    redis: redisRecipe,
+    websockets: websocketsRecipe,
+    email: emailRecipe,
+    docker: dockerRecipe,
+    queue: queueRecipe,
+    messaging: messagingRecipe,
+    openapi: openapiRecipe,
+    observability: observabilityRecipe,
+    cache: cacheRecipe,
+    storage: storageRecipe,
+    scheduler: schedulerRecipe,
+});
+/**
+ * Resolves a feature name (or alias) to its recipe.
+ *
+ * @throws {CLIValidationError} For refused or unknown names.
+ */
+export function resolveFeatureRecipe(name) {
+    const available = Object.keys(FEATURE_PACKAGES).join(", ");
+    const feature = Object.hasOwn(FEATURE_ALIASES, name) ? (FEATURE_ALIASES[name] ?? name) : name;
+    if (Object.hasOwn(FEATURE_REFUSALS, feature)) {
+        throw new CLIValidationError(`"${name}" cannot be added: ${FEATURE_REFUSALS[feature]}`);
+    }
+    // Own keys only: `constructor` or `__proto__` must not resolve to
+    // Object.prototype members.
+    const recipe = Object.hasOwn(FEATURE_RECIPES, feature) ? FEATURE_RECIPES[feature] : undefined;
+    if (recipe === undefined) {
+        throw new CLIValidationError(`Unknown feature: "${name}". Available: ${available}`);
+    }
+    return recipe;
+}
+//# sourceMappingURL=recipe.registry.js.map

package/dist/src/recipes/recipe.type.d.ts

@@ -0,0 +1,93 @@
+/**
+ * zudojs-cli — Feature recipes: what `zudojs add <feature>` writes.
+ *
+ * `add` used to install a package and write no code. Every feature it
+ * accepts now has a recipe: an app recipe adds an integration
+ * (`src/integrations/<name>.ts`, registered between the markers of
+ * `src/integrations/index.ts` and started/stopped with the runtime), its
+ * config section, its `.env.example` variables and its dependencies; a
+ * project recipe (docker) writes files at the project root.
+ */
+import type { EnvVariable } from "../templates/backendApp/index.js";
+import type { MarkerName } from "../wiring/index.js";
+/** What a recipe knows about the app it is applied to. */
+export interface RecipeContext {
+    /** Project name slug (database name, service names). */
+    readonly projectSlug: string;
+    /** App name: `app` for a single-app project, `gateway`, a service name. */
+    readonly appName: string;
+    /** Database engine recorded in the manifest (`postgresql`, ...). */
+    readonly database: string;
+    /** App root relative to the project root (`""`, `apps/gateway`). */
+    readonly appRoot: string;
+}
+/** A line inserted between the markers of `src/server.ts`. */
+export interface ServerLine {
+    readonly marker: MarkerName;
+    readonly line: string;
+}
+/** A recipe applied to each backend app. */
+export interface AppRecipe {
+    readonly scope: "app";
+    readonly feature: string;
+    /** One line for `zudojs add --help` style listings and the success message. */
+    readonly summary: string;
+    /** Throws a CLIValidationError when the app cannot take the feature. */
+    readonly validate?: (context: RecipeContext) => void;
+    readonly dependencies: Readonly<Record<string, string>>;
+    readonly devDependencies?: Readonly<Record<string, string>>;
+    /** Scripts added when missing; `replace` rewrites an existing value. */
+    readonly scripts?: Readonly<Record<string, string>>;
+    readonly replaceScripts?: Readonly<Record<string, {
+        from: string;
+        to: string;
+    }>>;
+    readonly env?: (context: RecipeContext) => readonly EnvVariable[];
+    /** Single-line entry for the config markers, e.g. `redis: Object.freeze({...}),`. */
+    readonly configSection?: string;
+    /** `src/integrations/<file>` exporting `<exportName>: Integration`. */
+    readonly integration?: {
+        readonly file: string;
+        readonly exportName: string;
+        readonly source: (context: RecipeContext) => string;
+    };
+    /** Extra files, relative to the app root, written only when missing. */
+    readonly files?: (context: RecipeContext) => Readonly<Record<string, string>>;
+    readonly serverLines?: (context: RecipeContext) => readonly ServerLine[];
+    /** Lines for the project's .gitignore. */
+    readonly gitignore?: (context: RecipeContext) => readonly string[];
+    /** Packages allowed to run install scripts (pnpm allowBuilds). */
+    readonly allowBuilds?: readonly string[];
+    /** What to do next, printed after the recipe is applied. */
+    readonly nextSteps?: (context: RecipeContext) => readonly string[];
+}
+/** Everything a project recipe needs to know. */
+export interface ProjectRecipeContext {
+    readonly root: string;
+    readonly projectSlug: string;
+    readonly architecture: string;
+    readonly packageManager: string;
+    readonly database: string;
+    /** Features already enabled anywhere in the project (plus this one). */
+    readonly features: ReadonlySet<string>;
+    /** Backend apps: root-relative directory, name and port. */
+    readonly apps: readonly {
+        readonly dir: string;
+        readonly name: string;
+        readonly port: number;
+        readonly prisma: boolean;
+    }[];
+}
+/** A recipe applied once, at the project root. */
+export interface ProjectRecipe {
+    readonly scope: "project";
+    readonly feature: string;
+    readonly summary: string;
+    /** Files to write (relative to the root); existing files are kept. */
+    readonly files: (context: ProjectRecipeContext) => Readonly<Record<string, string>>;
+    readonly env?: (context: ProjectRecipeContext) => readonly EnvVariable[];
+    readonly nextSteps?: (context: ProjectRecipeContext) => readonly string[];
+}
+/** Any recipe. */
+export type FeatureRecipe = AppRecipe | ProjectRecipe;
+//# sourceMappingURL=recipe.type.d.ts.map

package/dist/src/recipes/recipe.type.js

@@ -0,0 +1,12 @@
+/**
+ * zudojs-cli — Feature recipes: what `zudojs add <feature>` writes.
+ *
+ * `add` used to install a package and write no code. Every feature it
+ * accepts now has a recipe: an app recipe adds an integration
+ * (`src/integrations/<name>.ts`, registered between the markers of
+ * `src/integrations/index.ts` and started/stopped with the runtime), its
+ * config section, its `.env.example` variables and its dependencies; a
+ * project recipe (docker) writes files at the project root.
+ */
+export {};
+//# sourceMappingURL=recipe.type.js.map

package/dist/src/resolvers/dependency/dependencyVersions.constant.d.ts

@@ -1,12 +1,107 @@
 /**
- * Default version ranges for frontend dependencies the adapters request
- * without a version.
+ * Version ranges for every third-party package a generated project depends
+ * on: the ranges adapters request without a version, the framework
+ * toolchains the built-in fallback templates write, and the backend
+ * templates' dev tooling.
  *
  * Unpinned requirements used to be written as `"latest"`, so the same
- * scaffold produced a different dependency set every day. Every name a
- * built-in adapter requests unpinned has a caret range here (checked by
+ * scaffold produced a different dependency set every day, and the fallback
+ * templates carried their own literals that went stale independently (Vite
+ * 6, Next 15, Nuxt 3, Angular 19 and TypeScript 5 long after newer majors
+ * shipped). Every range now lives here. Every name a built-in adapter
+ * requests unpinned must have an entry (checked by
  * `tests/cli.round10.*.test.ts`). Ranges were taken from the npm registry on
- * 2026-09-19.
+ * 2026-09-23; pre-releases (for example Prisma 8 RCs or `@nuxt/devtools`
+ * betas tagged `latest`) are never used.
+ */
+export declare const DEPENDENCY_VERSION_RANGES: Readonly<{
+    readonly "@angular/build": "^22.1.8";
+    readonly "@angular/cli": "^22.1.8";
+    readonly "@angular/common": "^22.1.7";
+    readonly "@angular/compiler": "^22.1.7";
+    readonly "@angular/compiler-cli": "^22.1.7";
+    readonly "@angular/core": "^22.1.7";
+    readonly "@angular/forms": "^22.1.7";
+    readonly "@angular/platform-browser": "^22.1.7";
+    readonly "@angular/router": "^22.1.7";
+    readonly "@astrojs/check": "^0.9.10";
+    readonly "@ngrx/store": "^22.0.1";
+    readonly "@prisma/adapter-pg": "^7.10.0";
+    readonly "@prisma/client": "^7.10.0";
+    readonly "@sveltejs/adapter-auto": "^7.0.1";
+    readonly "@sveltejs/kit": "^2.70.3";
+    readonly "@sveltejs/vite-plugin-svelte": "^7.3.1";
+    readonly "@testing-library/dom": "^10.4.2";
+    readonly "@testing-library/jest-dom": "^7.0.1";
+    readonly "@testing-library/react": "^16.3.3";
+    readonly "@testing-library/react-native": "^14.0.1";
+    readonly "@testing-library/svelte": "^5.4.2";
+    readonly "@testing-library/user-event": "^14.6.7";
+    readonly "@tsconfig/svelte": "^5.0.8";
+    readonly "@types/node": "^26.6.2";
+    readonly "@types/react": "^19.3.0";
+    readonly "@types/react-dom": "^19.3.0";
+    readonly "@types/ws": "^8.18.1";
+    readonly "@vitejs/plugin-react": "^6.1.1";
+    readonly "@vitejs/plugin-vue": "^6.0.9";
+    readonly "@vue/test-utils": "^2.5.1";
+    readonly "@vue/tsconfig": "^0.9.1";
+    readonly astro: "^7.3.4";
+    readonly eslint: "^10.11.0";
+    readonly "eslint-plugin-react-hooks": "^7.1.1";
+    readonly "eslint-plugin-react-refresh": "^0.5.7";
+    readonly "eslint-plugin-svelte": "^3.23.0";
+    readonly "eslint-plugin-vue": "^10.11.0";
+    readonly jest: "^30.5.2";
+    readonly jsdom: "^30.1.1";
+    readonly next: "^16.3.6";
+    readonly nodemailer: "^10.0.10";
+    readonly nuxt: "^4.5.2";
+    readonly pinia: "^4.0.3";
+    readonly prettier: "^3.9.9";
+    readonly prisma: "^7.10.0";
+    readonly "prettier-plugin-svelte": "^4.1.1";
+    readonly react: "^19.3.0";
+    readonly "react-dom": "^19.3.0";
+    readonly redis: "^6.2.1";
+    readonly rxjs: "~7.8.2";
+    readonly svelte: "^5.57.1";
+    readonly "svelte-check": "^4.7.6";
+    readonly tslib: "^2.8.1";
+    readonly tsx: "^4.23.15";
+    readonly "typescript-eslint": "^8.70.1";
+    readonly vite: "^8.3.0";
+    readonly vitest: "^5.0.1";
+    readonly vue: "^3.5.43";
+    readonly "vue-router": "^5.3.1";
+    readonly "vue-tsc": "^3.3.11";
+    readonly ws: "^8.21.3";
+    readonly zustand: "^5.0.15";
+}>;
+/**
+ * TypeScript ranges, split by where the compiler runs.
+ *
+ * Backend templates only run `tsc` and `tsx`, so they get TypeScript 7.
+ * Frontend toolchains call the TypeScript 6 JavaScript API and declare it
+ * as a peer: `@angular/compiler-cli` and `@angular/build` need
+ * `>=6.0 <6.1`, `typescript-eslint` needs `<6.1.0`, and `@sveltejs/kit`,
+ * `svelte-check` and `@astrojs/check` need `^5 || ^6`. The frontend range is
+ * therefore a tilde range on 6.0 — do not raise it to 7 until those peer
+ * ranges admit it.
+ */
+export declare const TYPESCRIPT_VERSION_RANGES: Readonly<{
+    readonly backend: "^7.0.2";
+    readonly frontend: "~6.0.3";
+}>;
+/**
+ * Vitest range for Angular projects. `@angular/build:unit-test` declares
+ * `vitest` `^4.0.8` as a peer, so Angular cannot take the Vitest 5 range the
+ * other frameworks use.
+ */
+export declare const ANGULAR_VITEST_VERSION_RANGE = "^4.1.11";
+/**
+ * Default ranges the dependency resolver applies to requirements that carry
+ * no version of their own.
  */
 export declare const DEFAULT_DEPENDENCY_VERSIONS: ReadonlyMap<string, string>;
 //# sourceMappingURL=dependencyVersions.constant.d.ts.map